Light, fluffy, and always free - The AWS Local Emulator alternative
fix(elb): route Classic (v1) requests to a dedicated handler instead of ELBv2 (#2619)
Allen Sanbornafe26c6ad179
diff --git a/docs/services/elb-classic.md b/docs/services/elb-classic.mdnew file mode 100644index 0000000000..9e39e0e945--- /dev/null+++ b/docs/services/elb-classic.md@@ -0,0 +1,109 @@+# Elastic Load Balancing (Classic, v1)++**Protocol:** Query (XML) — `POST http://localhost:4566/` with `Action=` and `Version=2012-06-01`++Classic Elastic Load Balancing is the 2012-06-01 API behind `aws elb` and Terraform's `aws_elb`+resource. It is a **different API** from [ELB v2](elb.md) (ALB/NLB, 2015-12-01), even though both+are served from the same endpoint host and signed with the same `elasticloadbalancing` credential+scope.++## How Floci tells the two apart++Every Query-protocol request carries the API version it is speaking as the `Version` form+parameter, and that is what Floci routes on:++| `Version` | Answered by |+|---|---|+| `2012-06-01` | Classic (this page) |+| `2015-12-01` | [ELB v2](elb.md) |++Responses are emitted in the matching namespace —+`http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/` for Classic. A Classic+`CreateLoadBalancer` returns `DNSName` and nothing else; Classic load balancers have no ARN and+are addressed by `LoadBalancerName` for their whole life.++If a hand-rolled client omits `Version`, Floci falls back to the request shape: an action unique+to one API decides, and for the action names both APIs define (`CreateLoadBalancer`,+`DescribeLoadBalancers`, `AddTags`, …) the presence of `LoadBalancerName` or `LoadBalancerNames`+selects Classic. With neither present the request goes to ELB v2.++## Supported Actions++| Action | Description |+|--------|-------------|+| CreateLoadBalancer | Creates a Classic load balancer with listeners, subnets or AZs, security groups, scheme, and tags. Returns `DNSName`. |+| DescribeLoadBalancers | Returns `LoadBalancerDescription` records, optionally filtered by `LoadBalancerNames`. |+| DeleteLoadBalancer | Deletes a load balancer; deleting one that does not exist succeeds. |+| CreateLoadBalancerListeners | Adds listeners. A conflicting listener on a port already in use is rejected with `DuplicateListener`. |+| DeleteLoadBalancerListeners | Removes listeners by `LoadBalancerPorts`. |+| ConfigureHealthCheck | Replaces the health check and re-arms Floci's checker. |+| RegisterInstancesWithLoadBalancer | Registers EC2 instances and returns the full registered set. |+| DeregisterInstancesFromLoadBalancer | Removes instances and returns the remaining set. |+| DescribeInstanceHealth | Returns `InstanceStates` for the named instances, or for every registered instance. |+| ModifyLoadBalancerAttributes | Updates cross-zone, access log, connection draining, connection settings, and additional attributes. Unsent members keep their current value. |+| DescribeLoadBalancerAttributes | Returns the full attribute structure. |+| ApplySecurityGroupsToLoadBalancer | Replaces the security groups. |+| AttachLoadBalancerToSubnets / DetachLoadBalancerFromSubnets | Adds or removes subnets and recomputes the availability zones and VPC. |+| EnableAvailabilityZonesForLoadBalancer / DisableAvailabilityZonesForLoadBalancer | Adds or removes availability zones. |+| AddTags / RemoveTags / DescribeTags | Tagging, keyed by `LoadBalancerNames`. |+| DescribeAccountLimits | Returns standard default Classic limits. |++## Not implemented++These Classic operations return `UnsupportedOperation` in the 2012-06-01 namespace rather than a+fabricated result:++`CreateAppCookieStickinessPolicy`, `CreateLBCookieStickinessPolicy`, `CreateLoadBalancerPolicy`,+`DeleteLoadBalancerPolicy`, `DescribeLoadBalancerPolicies`, `DescribeLoadBalancerPolicyTypes`,+`SetLoadBalancerPoliciesForBackendServer`, `SetLoadBalancerPoliciesOfListener`,+`SetLoadBalancerListenerSSLCertificate`.++Floci also does not run a Classic **data plane**: listener ports are recorded but no socket is+opened and no traffic is forwarded. Only the control plane and health checking are emulated.++## Behavior Notes++- Load balancer state is persisted through Floci storage and health checking is restarted on+ startup.+- A new load balancer gets AWS's default health check (`TCP:80`, interval 30, timeout 5,+ unhealthy 2, healthy 10) and AWS's default attributes (cross-zone off, access log off,+ connection draining off with a 300 second timeout, 60 second idle timeout).+- Health checks probe the instance's reachable local address. `HTTP:`/`HTTPS:` targets are probed+ with an HTTP request to the target's path and any 2xx/3xx is healthy; `TCP:`/`SSL:` targets are+ probed by connecting. TLS is not terminated — an `HTTPS:` target is probed over plain HTTP on+ the same port.+- Between registration and the first successful check an instance reports `OutOfService` with+ reason code `ELB`, as it does on AWS.+- An Auto Scaling group that names Classic load balancers in `LoadBalancerNames` has its instances+ registered and deregistered automatically, so a Terraform `min_elb_capacity` wait can be+ satisfied.++## Configuration++| Environment variable | Default | Description |+|---|---|---|+| `FLOCI_SERVICES_ELB_ENABLED` | `true` | Enable or disable the Classic ELB service |+| `FLOCI_SERVICES_ELB_MOCK` | `false` | When `true`, never probe: a registered instance is `InService` immediately |++## Examples++```bash+export AWS_ENDPOINT_URL=http://localhost:4566++aws elb create-load-balancer \+ --load-balancer-name my-classic-elb \+ --listeners "Protocol=HTTP,LoadBalancerPort=80,InstanceProtocol=HTTP,InstancePort=8080" \+ --subnets subnet-12345678++aws elb configure-health-check \+ --load-balancer-name my-classic-elb \+ --health-check Target=HTTP:8080/,Interval=10,Timeout=3,UnhealthyThreshold=2,HealthyThreshold=2++aws elb register-instances-with-load-balancer \+ --load-balancer-name my-classic-elb \+ --instances i-1234567890abcdef0++aws elb describe-instance-health --load-balancer-name my-classic-elb++aws elb delete-load-balancer --load-balancer-name my-classic-elb+```diff --git a/docs/services/elb.md b/docs/services/elb.mdindex 8704952b96..d7b7b3d0a5 100644--- a/docs/services/elb.md+++ b/docs/services/elb.md@@ -4,6 +4,10 @@Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB) through the ELBv2 management API. The control plane is AWS SDK / CLI / Terraform compatible, and HTTP listeners can forward to registered instance targets using the target's reachable local address.+> Classic (v1) Elastic Load Balancing is a **different API** served from the same endpoint host —+> see [ELB Classic (v1)](elb-classic.md). Requests are routed by their `Version` parameter:+> `2015-12-01` here, `2012-06-01` there.+## Supported Actions### Load Balancersdiff --git a/mkdocs.yml b/mkdocs.ymlindex a32fee9b88..f2c25126ab 100644--- a/mkdocs.yml+++ b/mkdocs.yml@@ -132,6 +132,7 @@ nav:- Bedrock Runtime: services/bedrock-runtime.md- Bedrock AgentCore: services/bedrock-agentcore.md- ELB v2: services/elb.md+ - ELB Classic (v1): services/elb-classic.md- Auto Scaling: services/autoscaling.md- Application Auto Scaling: services/applicationautoscaling.md- Elastic Beanstalk: services/elastic-beanstalk.mddiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 40fdf62332..79d4c0992a 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -659,6 +659,7 @@ public interface EmulatorConfig {PipesServiceConfig pipes();BedrockAgentCoreControlServiceConfig bedrockAgentCoreControl();BedrockAgentCoreServiceConfig bedrockAgentCore();+ ElbServiceConfig elb();ElbV2ServiceConfig elbv2();CodeBuildServiceConfig codebuild();CodeDeployServiceConfig codedeploy();@@ -2079,6 +2080,16 @@ public interface EmulatorConfig {boolean validateRuntimeExists();}+ /** Classic (2012-06-01) Elastic Load Balancing — a separate API from {@link ElbV2ServiceConfig}. */+ interface ElbServiceConfig {+ @WithDefault("true")+ boolean enabled();++ /** When true, no health check is ever probed and a registered instance is InService at once. */+ @WithDefault("false")+ boolean mock();+ }+interface ElbV2ServiceConfig {@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.javaindex 0936f33df0..c7118c8612 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@@ -17,6 +17,10 @@ public final class AwsNamespaces {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/";+ /** Classic (v1) Elastic Load Balancing. Shares an endpoint host with {@link #ELB_V2},+ * but is a different API: requests declaring {@code Version=2012-06-01} must be answered+ * in this namespace, never in the 2015-12-01 one. */+ public static final String ELB_CLASSIC = "http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/";public static final String ELB_V2 = "https://elasticloadbalancing.amazonaws.com/doc/2015-12-01/";public static final String AUTOSCALING = "https://autoscaling.amazonaws.com/doc/2011-01-01/";public static final String ELASTIC_BEANSTALK = "https://elasticbeanstalk.amazonaws.com/docs/2010-12-01/";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.javaindex f2689e54d0..88e6db23a2 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@@ -8,6 +8,7 @@ import io.github.hectorvent.floci.services.autoscaling.AutoScalingQueryHandler;import io.github.hectorvent.floci.services.cloudformation.CloudFormationQueryHandler;import io.github.hectorvent.floci.services.ec2.Ec2QueryHandler;import io.github.hectorvent.floci.services.elasticbeanstalk.ElasticBeanstalkQueryHandler;+import io.github.hectorvent.floci.services.elb.ElbClassicQueryHandler;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;@@ -195,6 +196,7 @@ public class AwsQueryController {private final CognitoJsonHandler cognitoJsonHandler;private final Ec2QueryHandler ec2QueryHandler;private final ElbV2QueryHandler elbV2QueryHandler;+ private final ElbClassicQueryHandler elbClassicQueryHandler;private final AutoScalingQueryHandler autoScalingQueryHandler;private final ElasticBeanstalkQueryHandler elasticBeanstalkQueryHandler;private final RedshiftQueryHandler redshiftQueryHandler;@@ -217,6 +219,7 @@ public class AwsQueryController {CognitoJsonHandler cognitoJsonHandler,Ec2QueryHandler ec2QueryHandler,ElbV2QueryHandler elbV2QueryHandler,+ ElbClassicQueryHandler elbClassicQueryHandler,AutoScalingQueryHandler autoScalingQueryHandler,ElasticBeanstalkQueryHandler elasticBeanstalkQueryHandler,RedshiftQueryHandler redshiftQueryHandler,@@ -239,6 +242,7 @@ public class AwsQueryController {this.cognitoJsonHandler = cognitoJsonHandler;this.ec2QueryHandler = ec2QueryHandler;this.elbV2QueryHandler = elbV2QueryHandler;+ this.elbClassicQueryHandler = elbClassicQueryHandler;this.autoScalingQueryHandler = autoScalingQueryHandler;this.elasticBeanstalkQueryHandler = elasticBeanstalkQueryHandler;this.redshiftQueryHandler = redshiftQueryHandler;@@ -343,7 +347,9 @@ 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);+ case "elasticloadbalancing" -> isElbClassicRequest(action, formParams)+ ? elbClassicQueryHandler.handle(action, formParams, region)+ : elbV2QueryHandler.handle(action, formParams, region);case "autoscaling" -> autoScalingQueryHandler.handle(action, formParams, region);case "elasticbeanstalk" -> elasticBeanstalkQueryHandler.handle(action, formParams, region);case "redshift" -> redshiftQueryHandler.handle(action, formParams);@@ -352,6 +358,48 @@ public class AwsQueryController {};}+ /** The API version a Classic (v1) Elastic Load Balancing request declares. */+ private static final String ELB_CLASSIC_API_VERSION = "2012-06-01";++ /** The API version an ELBv2 (ALB/NLB) request declares. */+ private static final String ELB_V2_API_VERSION = "2015-12-01";++ /**+ * Whether an {@code elasticloadbalancing} request is for the Classic (2012-06-01) API.+ *+ * <p>Classic ELB and ELBv2 share an endpoint host <em>and</em> a credential scope, so the+ * service name cannot separate them — the same in-case split the {@code rds} scope already+ * needs for Neptune and DocumentDB. What separates them is the API version, which every+ * Query-protocol request carries as the {@code Version} form parameter and which both service+ * models declare. That is the discriminator used here, in preference to guessing from the+ * shape of the parameters: a client that says {@code Version=2012-06-01} has told us which API+ * it is speaking, and answering it from the other one is the defect this routing exists to fix.+ *+ * <p>The parameter shape is only a fallback, for a hand-rolled client that omitted+ * {@code Version}. Then an action unique to one API decides, and for the action names both+ * APIs define, the presence of a Classic-only parameter does: {@code LoadBalancerName} or+ * {@code LoadBalancerNames} identify a load balancer by name, which is Classic's addressing+ * model, whereas ELBv2 uses {@code LoadBalancerArn}, {@code Name} or {@code ResourceArns}.+ * With neither present the request stays with ELBv2, which is the pre-existing behaviour.+ */+ private static boolean isElbClassicRequest(String action, MultivaluedMap<String, String> formParams) {+ String version = formParams.getFirst("Version");+ if (ELB_CLASSIC_API_VERSION.equals(version)) {+ return true;+ }+ if (ELB_V2_API_VERSION.equals(version)) {+ return false;+ }+ if (ElbClassicQueryHandler.CLASSIC_ONLY_ACTIONS.contains(action)) {+ return true;+ }+ if (!ElbClassicQueryHandler.SHARED_ACTIONS.contains(action)) {+ return false;+ }+ return formParams.getFirst("LoadBalancerName") != null+ || formParams.getFirst("LoadBalancerNames.member.1") != null;+ }+/*** The AlreadyExists answer when a create names an identifier RDS already holds here, or null.*@@ -589,7 +637,8 @@ public class AwsQueryController {if (EC2_ACTIONS.contains(action)) {return "ec2";}- if (ELB_V2_ACTIONS.contains(action)) {+ if (ELB_V2_ACTIONS.contains(action)+ || ElbClassicQueryHandler.CLASSIC_ONLY_ACTIONS.contains(action)) {return "elasticloadbalancing";}if (AUTOSCALING_ACTIONS.contains(action)) {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.javaindex 5b96a52572..ab6dc75999 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@@ -340,6 +340,14 @@ public class ResolvedServiceCatalog {"elbv2", config.storage().mode(), 5000L, AwsNamespaces.ELB_V2, ServiceProtocol.QUERY,protocols(ServiceProtocol.QUERY),Set.of(), Set.of("elasticloadbalancing"), Set.of(), Set.of()),+ // Classic (v1) ELB shares the elasticloadbalancing endpoint and credential scope+ // with ELBv2 above, so it claims neither here; AwsQueryController splits the two on+ // the request's Version parameter. Listed so the service and its config knob are+ // visible in status.+ descriptor("elb", "elb", config.services().elb().enabled(), true,+ "elb", config.storage().mode(), 5000L, AwsNamespaces.ELB_CLASSIC, ServiceProtocol.QUERY,+ protocols(ServiceProtocol.QUERY),+ Set.of(), Set.of(), Set.of(), Set.of()),descriptor("codebuild", "codebuild", config.services().codebuild().enabled(), true,"codebuild", storageMode(config.storage().services().codebuild().mode(), config.storage().mode()),config.storage().services().codebuild().flushIntervalMs(), null, ServiceProtocol.JSON,diff --git a/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java b/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.javaindex af1ae39e7e..2e2229071e 100644--- a/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java+++ b/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java@@ -25,6 +25,7 @@ import io.github.hectorvent.floci.services.neptune.container.NeptuneContainerManimport io.github.hectorvent.floci.services.neptune.proxy.NeptuneProxyManager;import io.github.hectorvent.floci.services.pipes.PipesService;import io.github.hectorvent.floci.services.appsync.graphql.SchemaCreationWorker;+import io.github.hectorvent.floci.services.elb.ElbClassicService;import io.github.hectorvent.floci.services.elbv2.ElbV2Service;import io.github.hectorvent.floci.services.rds.RdsService;import io.github.hectorvent.floci.services.memorydb.container.MemoryDbContainerManager;@@ -82,6 +83,7 @@ public class EmulatorLifecycle {private final FlinkContainerManager flinkContainerManager;private final RdsService rdsService;private final ElbV2Service elbV2Service;+ private final ElbClassicService elbClassicService;private final InitializationHooksRunner initializationHooksRunner;private final SqsEventSourcePoller sqsPoller;private final KinesisEventSourcePoller kinesisPoller;@@ -114,6 +116,7 @@ public class EmulatorLifecycle {FlinkContainerManager flinkContainerManager,RdsService rdsService,ElbV2Service elbV2Service,+ ElbClassicService elbClassicService,InitializationHooksRunner initializationHooksRunner,SqsEventSourcePoller sqsPoller,KinesisEventSourcePoller kinesisPoller,@@ -145,6 +148,7 @@ public class EmulatorLifecycle {this.flinkContainerManager = flinkContainerManager;this.rdsService = rdsService;this.elbV2Service = elbV2Service;+ this.elbClassicService = elbClassicService;this.initializationHooksRunner = initializationHooksRunner;this.sqsPoller = sqsPoller;this.kinesisPoller = kinesisPoller;@@ -202,6 +206,9 @@ public class EmulatorLifecycle {if (config.services().elbv2().enabled()) {elbV2Service.restorePersistedRuntime();}+ if (config.services().elb().enabled()) {+ elbClassicService.restorePersistedRuntime();+ }if (config.services().ec2().enabled() && !config.services().ec2().mock()) {ec2MetadataServer.start().exceptionally(ex -> {diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.javaindex 31e7750ea0..0160e42210 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconciler.java@@ -8,6 +8,7 @@ import io.github.hectorvent.floci.services.ec2.Ec2Service;import io.github.hectorvent.floci.services.ec2.model.Instance;import io.github.hectorvent.floci.services.ec2.model.LaunchTemplate;import io.github.hectorvent.floci.services.ec2.model.Reservation;+import io.github.hectorvent.floci.services.elb.ElbClassicService;import io.github.hectorvent.floci.services.elbv2.ElbV2Service;import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;import io.github.hectorvent.floci.services.elbv2.model.TargetHealth;@@ -37,22 +38,25 @@ public class AutoScalingReconciler {private final AutoScalingService asgService;private final Ec2Service ec2Service;private final ElbV2Service elbV2Service;+ private final ElbClassicService elbClassicService;private final SsmCommandService ssmCommandService;private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(r -> new Thread(r, "asg-reconciler"));@InjectAutoScalingReconciler(AutoScalingService asgService, Ec2Service ec2Service,- ElbV2Service elbV2Service, SsmCommandService ssmCommandService) {+ ElbV2Service elbV2Service, ElbClassicService elbClassicService,+ SsmCommandService ssmCommandService) {this.asgService = asgService;this.ec2Service = ec2Service;this.elbV2Service = elbV2Service;+ this.elbClassicService = elbClassicService;this.ssmCommandService = ssmCommandService;}AutoScalingReconciler(AutoScalingService asgService, Ec2Service ec2Service,ElbV2Service elbV2Service) {- this(asgService, ec2Service, elbV2Service, null);+ this(asgService, ec2Service, elbV2Service, null, null);}@PostConstruct@@ -124,6 +128,7 @@ public class AutoScalingReconciler {asgInst.setLifecycleState("InService");asgInst.setHealthStatus("Healthy");registerWithTargetGroups(asg, asgInst);+ registerWithClassicLoadBalancers(asg, asgInst);changed = true;asgService.recordActivity(asg.getRegion(), asg.getAutoScalingGroupName(),"Launching a new EC2 instance: " + asgInst.getInstanceId(),@@ -154,6 +159,8 @@ public class AutoScalingReconciler {.map(AsgInstance::getInstanceId).collect(Collectors.toList());failActiveSsmInvocations(asg, instanceIds);+ deregisterFromTargetGroups(asg, instanceIds);+ deregisterFromClassicLoadBalancers(asg, instanceIds);asg.getInstances().removeIf(instance -> instanceIds.contains(instance.getInstanceId()));asgService.saveAutoScalingGroup(asg);asgService.recordActivity(asg.getRegion(), asg.getAutoScalingGroupName(),@@ -258,6 +265,7 @@ public class AutoScalingReconciler {.map(AsgInstance::getInstanceId).collect(Collectors.toList());deregisterFromTargetGroups(asg, instanceIds);+ deregisterFromClassicLoadBalancers(asg, instanceIds);try {ec2Service.terminateInstances(asg.getRegion(), instanceIds);} catch (Exception e) {@@ -361,6 +369,7 @@ public class AutoScalingReconciler {.collect(Collectors.toList());deregisterFromTargetGroups(asg, instanceIds);+ deregisterFromClassicLoadBalancers(asg, instanceIds);try {ec2Service.terminateInstances(asg.getRegion(), instanceIds);@@ -391,6 +400,45 @@ public class AutoScalingReconciler {}}+ /**+ * Registers a newly launched instance with every Classic load balancer the group names.+ *+ * <p>An ASG attached through {@code LoadBalancerNames} feeds a Classic load balancer, not a+ * target group, and the two lists are independent — a group can carry either or both. Without+ * this the Classic load balancer would stay empty, and a {@code min_elb_capacity} wait would+ * never be satisfied.+ */+ private void registerWithClassicLoadBalancers(AutoScalingGroup asg, AsgInstance asgInst) {+ if (elbClassicService == null) {+ return;+ }+ for (String lbName : asg.getLoadBalancerNames()) {+ try {+ elbClassicService.registerInstances(asg.getRegion(), lbName,+ List.of(asgInst.getInstanceId()));+ LOG.debugv("ASG {0}: registered {1} with Classic ELB {2}",+ asg.getAutoScalingGroupName(), asgInst.getInstanceId(), lbName);+ } catch (Exception e) {+ LOG.warnv("ASG {0}: could not register {1} with Classic ELB {2}: {3}",+ asg.getAutoScalingGroupName(), asgInst.getInstanceId(), lbName, e.getMessage());+ }+ }+ }++ private void deregisterFromClassicLoadBalancers(AutoScalingGroup asg, List<String> instanceIds) {+ if (elbClassicService == null) {+ return;+ }+ for (String lbName : asg.getLoadBalancerNames()) {+ try {+ elbClassicService.deregisterInstances(asg.getRegion(), lbName, instanceIds);+ } catch (Exception e) {+ LOG.debugv("ASG {0}: could not deregister from Classic ELB {1}: {2}",+ asg.getAutoScalingGroupName(), lbName, e.getMessage());+ }+ }+ }+private void registerWithTargetGroups(AutoScalingGroup asg, AsgInstance asgInst) {for (String tgArn : asg.getTargetGroupARNs()) {try {diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicHealthChecker.java b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicHealthChecker.javanew file mode 100644index 0000000000..87246d59af--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicHealthChecker.java@@ -0,0 +1,283 @@+package io.github.hectorvent.floci.services.elb;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.Resettable;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.elb.model.ClassicHealthCheck;+import io.github.hectorvent.floci.services.elb.model.ClassicLoadBalancer;+import io.vertx.core.Vertx;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.io.IOException;+import java.net.HttpURLConnection;+import java.net.InetSocketAddress;+import java.net.Socket;+import java.net.URL;+import java.util.Collection;+import java.util.Map;+import java.util.concurrent.ConcurrentHashMap;++/**+ * Health checking for Classic (2012-06-01) load balancers.+ *+ * <p>Classic health is per instance on one load balancer, not per target on a target group, and+ * the check itself is described by a single {@code Target} string such as {@code HTTP:8080/} or+ * {@code TCP:80} rather than by separate protocol, port and path members — so this cannot reuse+ * {@code ElbV2HealthChecker}. The probing shape is deliberately the same: a Vert.x periodic timer+ * per load balancer, consecutive success/failure counters, and the configured thresholds.+ *+ * <p>With {@code floci.services.elb.mock=true} no probe is ever made and a registered instance is+ * reported {@code InService} straight away.+ */+@ApplicationScoped+public class ElbClassicHealthChecker implements Resettable {++ private static final Logger LOG = Logger.getLogger(ElbClassicHealthChecker.class);++ /** The health of one registered instance, in the {@code InstanceState} shape of the v1 model. */+ public record InstanceHealth(String state, String reasonCode, String description) {++ static InstanceHealth inService() {+ return new InstanceHealth("InService", "N/A", "N/A");+ }++ static InstanceHealth registering() {+ return new InstanceHealth("OutOfService", "ELB",+ "Instance registration is still in progress.");+ }++ static InstanceHealth failedChecks() {+ return new InstanceHealth("OutOfService", "Instance",+ "Instance has failed at least the UnhealthyThreshold number of health checks "+ + "consecutively.");+ }+ }++ private final Vertx vertx;+ private final EmulatorConfig config;+ private final Ec2Service ec2Service;++ // "region|lbName" → instanceId → state+ private final Map<String, Map<String, InstanceState>> states = new ConcurrentHashMap<>();+ // "region|lbName" → Vert.x timer id+ private final Map<String, Long> timers = new ConcurrentHashMap<>();++ @Inject+ public ElbClassicHealthChecker(Vertx vertx, EmulatorConfig config, Ec2Service ec2Service) {+ this.vertx = vertx;+ this.config = config;+ this.ec2Service = ec2Service;+ }++ public static String key(String region, String loadBalancerName) {+ return region + "|" + loadBalancerName;+ }++ public void startMonitoring(ClassicLoadBalancer lb) {+ String k = key(lb.getRegion(), lb.getLoadBalancerName());+ states.computeIfAbsent(k, x -> new ConcurrentHashMap<>());+ if (mock() || vertx == null) {+ return;+ }+ stopTimer(k);+ int interval = lb.getHealthCheck() != null && lb.getHealthCheck().getInterval() != null+ ? lb.getHealthCheck().getInterval() : 30;+ timers.put(k, vertx.setPeriodic(interval * 1000L, id -> probeAll(lb)));+ }++ public void stopMonitoring(String region, String loadBalancerName) {+ String k = key(region, loadBalancerName);+ stopTimer(k);+ states.remove(k);+ }++ /** Re-arms the periodic timer after {@code ConfigureHealthCheck} changed the interval. */+ public void healthCheckChanged(ClassicLoadBalancer lb) {+ if (states.containsKey(key(lb.getRegion(), lb.getLoadBalancerName()))) {+ startMonitoring(lb);+ }+ }++ public void registerInstances(ClassicLoadBalancer lb, Collection<String> instanceIds) {+ Map<String, InstanceState> lbStates =+ states.computeIfAbsent(key(lb.getRegion(), lb.getLoadBalancerName()),+ k -> new ConcurrentHashMap<>());+ for (String id : instanceIds) {+ lbStates.putIfAbsent(id, new InstanceState());+ }+ if (!mock() && vertx != null) {+ vertx.setTimer(1, ignored -> probeAll(lb));+ }+ }++ public void deregisterInstances(String region, String loadBalancerName, Collection<String> instanceIds) {+ Map<String, InstanceState> lbStates = states.get(key(region, loadBalancerName));+ if (lbStates != null) {+ instanceIds.forEach(lbStates::remove);+ }+ }++ /**+ * The health of one instance registered with a load balancer.+ *+ * <p>An instance with no probe result yet is {@code OutOfService}/{@code ELB}, which is what a+ * live Classic load balancer reports between {@code RegisterInstancesWithLoadBalancer} and the+ * first successful check.+ */+ public InstanceHealth getHealth(String region, String loadBalancerName, String instanceId) {+ if (mock()) {+ return InstanceHealth.inService();+ }+ Map<String, InstanceState> lbStates = states.get(key(region, loadBalancerName));+ InstanceState s = lbStates != null ? lbStates.get(instanceId) : null;+ if (s == null || s.health == null) {+ return InstanceHealth.registering();+ }+ return s.health;+ }++ @Override+ public void clear() {+ if (vertx != null) {+ timers.values().forEach(vertx::cancelTimer);+ }+ timers.clear();+ states.clear();+ }++ private boolean mock() {+ return config != null && config.services().elb().mock();+ }++ private void stopTimer(String k) {+ Long timerId = timers.remove(k);+ if (timerId != null && vertx != null) {+ vertx.cancelTimer(timerId);+ }+ }++ private void probeAll(ClassicLoadBalancer lb) {+ Map<String, InstanceState> lbStates = states.get(key(lb.getRegion(), lb.getLoadBalancerName()));+ if (lbStates == null || lbStates.isEmpty()) {+ return;+ }+ ClassicHealthCheck hc = lb.getHealthCheck() != null ? lb.getHealthCheck() : ClassicHealthCheck.defaults();+ Target target = Target.parse(hc.getTarget());+ if (target == null) {+ return;+ }+ int timeout = hc.getTimeout() != null ? hc.getTimeout() : 5;+ int healthyThreshold = hc.getHealthyThreshold() != null ? hc.getHealthyThreshold() : 10;+ int unhealthyThreshold = hc.getUnhealthyThreshold() != null ? hc.getUnhealthyThreshold() : 2;++ for (Map.Entry<String, InstanceState> entry : lbStates.entrySet()) {+ String instanceId = entry.getKey();+ InstanceState state = entry.getValue();+ String host = resolveHost(instanceId);+ vertx.executeBlocking(() -> probe(host, target, timeout))+ .onSuccess(ok -> {+ if (Boolean.TRUE.equals(ok)) {+ state.consecutiveFailures = 0;+ state.consecutiveSuccesses++;+ if (state.consecutiveSuccesses >= healthyThreshold) {+ state.health = InstanceHealth.inService();+ }+ } else {+ recordFailure(state, unhealthyThreshold);+ }+ })+ .onFailure(err -> {+ recordFailure(state, unhealthyThreshold);+ LOG.debugv("Classic ELB health check failed for {0} ({1}): {2}",+ instanceId, host, err.getMessage());+ });+ }+ }++ private static void recordFailure(InstanceState state, int unhealthyThreshold) {+ state.consecutiveSuccesses = 0;+ state.consecutiveFailures++;+ if (state.consecutiveFailures >= unhealthyThreshold) {+ state.health = InstanceHealth.failedChecks();+ }+ }++ private String resolveHost(String instanceId) {+ if (ec2Service == null) {+ return instanceId;+ }+ Instance instance = ec2Service.findInstanceById(instanceId);+ if (instance == null) {+ return instanceId;+ }+ String bridgeIp = instance.getContainerBridgeIp();+ return bridgeIp != null && !bridgeIp.isBlank() ? bridgeIp : instanceId;+ }++ private static boolean probe(String host, Target target, int timeoutSeconds) throws IOException {+ int timeoutMs = timeoutSeconds * 1000;+ if (target.path() == null) {+ try (Socket socket = new Socket()) {+ socket.connect(new InetSocketAddress(host, target.port()), timeoutMs);+ return true;+ }+ }+ URL url = new URL(target.scheme(), host, target.port(), target.path());+ HttpURLConnection conn = (HttpURLConnection) url.openConnection();+ conn.setConnectTimeout(timeoutMs);+ conn.setReadTimeout(timeoutMs);+ conn.setInstanceFollowRedirects(false);+ try {+ int code = conn.getResponseCode();+ // Classic ELB treats any 2xx or 3xx as a healthy HTTP check.+ return code >= 200 && code < 400;+ } finally {+ conn.disconnect();+ }+ }++ /**+ * A parsed {@code HealthCheck.Target} — {@code HTTP:8080/health}, {@code TCP:80}, and so on.+ * {@code path} is null for the connection-only protocols, which is what selects a TCP probe.+ */+ record Target(String scheme, int port, String path) {++ static Target parse(String raw) {+ if (raw == null || raw.isBlank()) {+ return null;+ }+ int colon = raw.indexOf(':');+ if (colon < 0) {+ return null;+ }+ String protocol = raw.substring(0, colon).toUpperCase();+ String rest = raw.substring(colon + 1);+ int slash = rest.indexOf('/');+ String portPart = slash < 0 ? rest : rest.substring(0, slash);+ String path = slash < 0 ? null : rest.substring(slash);+ int port;+ try {+ port = Integer.parseInt(portPart.trim());+ } catch (NumberFormatException e) {+ return null;+ }+ return switch (protocol) {+ case "HTTP" -> new Target("http", port, path != null ? path : "/");+ // Floci does not terminate TLS for Classic health checks; an HTTPS target is+ // probed over plain HTTP against the same port rather than reported unknown.+ case "HTTPS" -> new Target("http", port, path != null ? path : "/");+ case "TCP", "SSL" -> new Target(null, port, null);+ default -> null;+ };+ }+ }++ private static final class InstanceState {+ volatile InstanceHealth health;+ volatile int consecutiveSuccesses;+ volatile int consecutiveFailures;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicQueryHandler.javanew file mode 100644index 0000000000..bcf92c12c3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicQueryHandler.java@@ -0,0 +1,621 @@+package io.github.hectorvent.floci.services.elb;++import io.github.hectorvent.floci.config.EmulatorConfig;+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.elb.model.ClassicHealthCheck;+import io.github.hectorvent.floci.services.elb.model.ClassicListener;+import io.github.hectorvent.floci.services.elb.model.ClassicLoadBalancer;+import io.github.hectorvent.floci.services.elb.model.ClassicLoadBalancerAttributes;+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.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Set;++/**+ * Query-protocol handler for Classic (2012-06-01) Elastic Load Balancing.+ *+ * <p>Every response is emitted in the 2012-06-01 namespace with the wrapper element names the+ * 2012-06-01 model declares. A Classic {@code CreateLoadBalancer} answer carries {@code DNSName}+ * and nothing else — no ARN and no {@code LoadBalancers} member list, both of which belong to the+ * 2015-12-01 API.+ *+ * <p><b>Scope.</b> Implemented are the operations the AWS provider drives for {@code aws_elb} and+ * for an Auto Scaling group attached to one. The stickiness- and backend-policy operations are not+ * implemented and are answered with {@code UnsupportedOperation}, which is honest and lets a caller+ * see the boundary, rather than a fabricated success.+ */+@ApplicationScoped+public class ElbClassicQueryHandler {++ private static final Logger LOG = Logger.getLogger(ElbClassicQueryHandler.class);++ private static final DateTimeFormatter ISO_FMT =+ DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneOffset.UTC);++ /**+ * Actions that exist only in the Classic API. Used by the dispatcher to route a request that+ * arrived without a {@code Version} parameter, and never overlapping {@link #SHARED_ACTIONS}.+ */+ public static final Set<String> CLASSIC_ONLY_ACTIONS = Set.of(+ "ConfigureHealthCheck",+ "RegisterInstancesWithLoadBalancer", "DeregisterInstancesFromLoadBalancer",+ "DescribeInstanceHealth",+ "CreateLoadBalancerListeners", "DeleteLoadBalancerListeners",+ "SetLoadBalancerListenerSSLCertificate",+ "ApplySecurityGroupsToLoadBalancer",+ "AttachLoadBalancerToSubnets", "DetachLoadBalancerFromSubnets",+ "EnableAvailabilityZonesForLoadBalancer", "DisableAvailabilityZonesForLoadBalancer",+ "CreateAppCookieStickinessPolicy", "CreateLBCookieStickinessPolicy",+ "CreateLoadBalancerPolicy", "DeleteLoadBalancerPolicy",+ "DescribeLoadBalancerPolicies", "DescribeLoadBalancerPolicyTypes",+ "SetLoadBalancerPoliciesForBackendServer", "SetLoadBalancerPoliciesOfListener"+ );++ /** Action names that both API versions define, and so cannot route on their own. */+ public static final Set<String> SHARED_ACTIONS = Set.of(+ "CreateLoadBalancer", "DeleteLoadBalancer", "DescribeLoadBalancers",+ "ModifyLoadBalancerAttributes", "DescribeLoadBalancerAttributes",+ "AddTags", "RemoveTags", "DescribeTags", "DescribeAccountLimits"+ );++ private static final Map<String, String> ACCOUNT_LIMITS = new LinkedHashMap<>();++ static {+ ACCOUNT_LIMITS.put("classic-load-balancers", "20");+ ACCOUNT_LIMITS.put("classic-listeners", "100");+ ACCOUNT_LIMITS.put("classic-registered-instances", "1000");+ }++ private final ElbClassicService service;+ private final EmulatorConfig config;++ @Inject+ public ElbClassicQueryHandler(ElbClassicService service, EmulatorConfig config) {+ this.service = service;+ this.config = config;+ }++ public Response handle(String action, MultivaluedMap<String, String> params, String region) {+ LOG.debugv("ELB Classic action: {0}", action);+ if (!config.services().elb().enabled()) {+ return xmlError("ServiceUnavailable",+ "The Elastic Load Balancing 2012-06-01 API is disabled "+ + "(floci.services.elb.enabled=false).", 503);+ }+ try {+ return switch (action) {+ case "CreateLoadBalancer" -> createLoadBalancer(params, region);+ case "DeleteLoadBalancer" -> deleteLoadBalancer(params, region);+ case "DescribeLoadBalancers" -> describeLoadBalancers(params, region);+ case "CreateLoadBalancerListeners" -> createListeners(params, region);+ case "DeleteLoadBalancerListeners" -> deleteListeners(params, region);+ case "ConfigureHealthCheck" -> configureHealthCheck(params, region);+ case "RegisterInstancesWithLoadBalancer" -> registerInstances(params, region);+ case "DeregisterInstancesFromLoadBalancer" -> deregisterInstances(params, region);+ case "DescribeInstanceHealth" -> describeInstanceHealth(params, region);+ case "ModifyLoadBalancerAttributes" -> modifyAttributes(params, region);+ case "DescribeLoadBalancerAttributes" -> describeAttributes(params, region);+ case "ApplySecurityGroupsToLoadBalancer" -> applySecurityGroups(params, region);+ case "AttachLoadBalancerToSubnets" -> attachSubnets(params, region);+ case "DetachLoadBalancerFromSubnets" -> detachSubnets(params, region);+ case "EnableAvailabilityZonesForLoadBalancer" -> enableZones(params, region);+ case "DisableAvailabilityZonesForLoadBalancer" -> disableZones(params, region);+ case "AddTags" -> addTags(params, region);+ case "RemoveTags" -> removeTags(params, region);+ case "DescribeTags" -> describeTags(params, region);+ case "DescribeAccountLimits" -> describeAccountLimits();+ default -> xmlError("UnsupportedOperation",+ "Action " + action + " is not supported by the Elastic Load Balancing "+ + "2012-06-01 API in Floci.", 400);+ };+ } catch (AwsException e) {+ return xmlError(e.getErrorCode(), e.getMessage(), e.getHttpStatus());+ }+ }++ // ── Load balancers ────────────────────────────────────────────────────────++ private Response createLoadBalancer(MultivaluedMap<String, String> p, String region) {+ ClassicLoadBalancer lb = service.createLoadBalancer(+ region,+ p.getFirst("LoadBalancerName"),+ parseListeners(p, "Listeners"),+ memberList(p, "AvailabilityZones"),+ memberList(p, "Subnets"),+ memberList(p, "SecurityGroups"),+ p.getFirst("Scheme"),+ parseTags(p));++ // The 2012-06-01 model gives CreateAccessPointOutput exactly one member: DNSName.+ return ok(new XmlBuilder()+ .start("CreateLoadBalancerResponse", AwsNamespaces.ELB_CLASSIC)+ .start("CreateLoadBalancerResult")+ .elem("DNSName", lb.getDnsName())+ .end("CreateLoadBalancerResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("CreateLoadBalancerResponse")+ .build());+ }++ private Response deleteLoadBalancer(MultivaluedMap<String, String> p, String region) {+ service.deleteLoadBalancer(region, requireName(p));+ return emptyResult("DeleteLoadBalancer");+ }++ private Response describeLoadBalancers(MultivaluedMap<String, String> p, String region) {+ List<ClassicLoadBalancer> lbs = service.describeLoadBalancers(region, memberList(p, "LoadBalancerNames"));++ XmlBuilder xml = new XmlBuilder()+ .start("DescribeLoadBalancersResponse", AwsNamespaces.ELB_CLASSIC)+ .start("DescribeLoadBalancersResult")+ .start("LoadBalancerDescriptions");+ for (ClassicLoadBalancer lb : lbs) {+ xml.start("member").raw(loadBalancerDescriptionXml(lb)).end("member");+ }+ xml.end("LoadBalancerDescriptions")+ .end("DescribeLoadBalancersResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("DescribeLoadBalancersResponse");+ return ok(xml.build());+ }++ // ── Listeners ─────────────────────────────────────────────────────────────++ private Response createListeners(MultivaluedMap<String, String> p, String region) {+ service.createLoadBalancerListeners(region, requireName(p), parseListeners(p, "Listeners"));+ return emptyResult("CreateLoadBalancerListeners");+ }++ private Response deleteListeners(MultivaluedMap<String, String> p, String region) {+ List<Integer> ports = new ArrayList<>();+ for (String port : memberList(p, "LoadBalancerPorts")) {+ ports.add(Integer.parseInt(port));+ }+ service.deleteLoadBalancerListeners(region, requireName(p), ports);+ return emptyResult("DeleteLoadBalancerListeners");+ }++ // ── Health ────────────────────────────────────────────────────────────────++ private Response configureHealthCheck(MultivaluedMap<String, String> p, String region) {+ ClassicHealthCheck hc = new ClassicHealthCheck();+ hc.setTarget(p.getFirst("HealthCheck.Target"));+ hc.setInterval(intOrNull(p.getFirst("HealthCheck.Interval")));+ hc.setTimeout(intOrNull(p.getFirst("HealthCheck.Timeout")));+ hc.setUnhealthyThreshold(intOrNull(p.getFirst("HealthCheck.UnhealthyThreshold")));+ hc.setHealthyThreshold(intOrNull(p.getFirst("HealthCheck.HealthyThreshold")));++ ClassicHealthCheck stored = service.configureHealthCheck(region, requireName(p), hc);+ return ok(new XmlBuilder()+ .start("ConfigureHealthCheckResponse", AwsNamespaces.ELB_CLASSIC)+ .start("ConfigureHealthCheckResult")+ .raw(healthCheckXml(stored))+ .end("ConfigureHealthCheckResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("ConfigureHealthCheckResponse")+ .build());+ }++ private Response registerInstances(MultivaluedMap<String, String> p, String region) {+ List<String> registered = service.registerInstances(region, requireName(p), parseInstanceIds(p));+ return ok(instanceListResponse("RegisterInstancesWithLoadBalancer", registered));+ }++ private Response deregisterInstances(MultivaluedMap<String, String> p, String region) {+ List<String> remaining = service.deregisterInstances(region, requireName(p), parseInstanceIds(p));+ return ok(instanceListResponse("DeregisterInstancesFromLoadBalancer", remaining));+ }++ private Response describeInstanceHealth(MultivaluedMap<String, String> p, String region) {+ Map<String, ElbClassicHealthChecker.InstanceHealth> health =+ service.describeInstanceHealth(region, requireName(p), parseInstanceIds(p));++ XmlBuilder xml = new XmlBuilder()+ .start("DescribeInstanceHealthResponse", AwsNamespaces.ELB_CLASSIC)+ .start("DescribeInstanceHealthResult")+ .start("InstanceStates");+ for (Map.Entry<String, ElbClassicHealthChecker.InstanceHealth> e : health.entrySet()) {+ xml.start("member")+ .elem("InstanceId", e.getKey())+ .elem("State", e.getValue().state())+ .elem("ReasonCode", e.getValue().reasonCode())+ .elem("Description", e.getValue().description())+ .end("member");+ }+ xml.end("InstanceStates")+ .end("DescribeInstanceHealthResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("DescribeInstanceHealthResponse");+ return ok(xml.build());+ }++ // ── Attributes ────────────────────────────────────────────────────────────++ private Response modifyAttributes(MultivaluedMap<String, String> p, String region) {+ String prefix = "LoadBalancerAttributes.";+ Map<String, String> additional = new LinkedHashMap<>();+ int i = 1;+ while (true) {+ String key = p.getFirst(prefix + "AdditionalAttributes.member." + i + ".Key");+ if (key == null) break;+ additional.put(key, p.getFirst(prefix + "AdditionalAttributes.member." + i + ".Value"));+ i++;+ }+ ElbClassicService.AttributeUpdate update = new ElbClassicService.AttributeUpdate(+ boolOrNull(p.getFirst(prefix + "CrossZoneLoadBalancing.Enabled")),+ boolOrNull(p.getFirst(prefix + "AccessLog.Enabled")),+ p.getFirst(prefix + "AccessLog.S3BucketName"),+ p.getFirst(prefix + "AccessLog.S3BucketPrefix"),+ intOrNull(p.getFirst(prefix + "AccessLog.EmitInterval")),+ boolOrNull(p.getFirst(prefix + "ConnectionDraining.Enabled")),+ intOrNull(p.getFirst(prefix + "ConnectionDraining.Timeout")),+ intOrNull(p.getFirst(prefix + "ConnectionSettings.IdleTimeout")),+ additional);++ ClassicLoadBalancer lb = service.modifyLoadBalancerAttributes(region, requireName(p), update);+ return ok(new XmlBuilder()+ .start("ModifyLoadBalancerAttributesResponse", AwsNamespaces.ELB_CLASSIC)+ .start("ModifyLoadBalancerAttributesResult")+ .elem("LoadBalancerName", lb.getLoadBalancerName())+ .raw(attributesXml(lb.getAttributes()))+ .end("ModifyLoadBalancerAttributesResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("ModifyLoadBalancerAttributesResponse")+ .build());+ }++ private Response describeAttributes(MultivaluedMap<String, String> p, String region) {+ ClassicLoadBalancer lb = service.requireLoadBalancer(region, requireName(p));+ return ok(new XmlBuilder()+ .start("DescribeLoadBalancerAttributesResponse", AwsNamespaces.ELB_CLASSIC)+ .start("DescribeLoadBalancerAttributesResult")+ .raw(attributesXml(lb.getAttributes()))+ .end("DescribeLoadBalancerAttributesResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("DescribeLoadBalancerAttributesResponse")+ .build());+ }++ // ── Zones, subnets, security groups ───────────────────────────────────────++ private Response applySecurityGroups(MultivaluedMap<String, String> p, String region) {+ List<String> sgs = service.applySecurityGroups(region, requireName(p), memberList(p, "SecurityGroups"));+ return ok(stringListResponse("ApplySecurityGroupsToLoadBalancer", "SecurityGroups", sgs));+ }++ private Response attachSubnets(MultivaluedMap<String, String> p, String region) {+ List<String> subnets = service.attachToSubnets(region, requireName(p), memberList(p, "Subnets"));+ return ok(stringListResponse("AttachLoadBalancerToSubnets", "Subnets", subnets));+ }++ private Response detachSubnets(MultivaluedMap<String, String> p, String region) {+ List<String> subnets = service.detachFromSubnets(region, requireName(p), memberList(p, "Subnets"));+ return ok(stringListResponse("DetachLoadBalancerFromSubnets", "Subnets", subnets));+ }++ private Response enableZones(MultivaluedMap<String, String> p, String region) {+ List<String> zones = service.enableAvailabilityZones(region, requireName(p),+ memberList(p, "AvailabilityZones"));+ return ok(stringListResponse("EnableAvailabilityZonesForLoadBalancer", "AvailabilityZones", zones));+ }++ private Response disableZones(MultivaluedMap<String, String> p, String region) {+ List<String> zones = service.disableAvailabilityZones(region, requireName(p),+ memberList(p, "AvailabilityZones"));+ return ok(stringListResponse("DisableAvailabilityZonesForLoadBalancer", "AvailabilityZones", zones));+ }++ // ── Tags ──────────────────────────────────────────────────────────────────++ private Response addTags(MultivaluedMap<String, String> p, String region) {+ service.addTags(region, memberList(p, "LoadBalancerNames"), parseTags(p));+ return emptyResult("AddTags");+ }++ private Response removeTags(MultivaluedMap<String, String> p, String region) {+ // RemoveTags carries TagKeyOnly members — Key without Value.+ List<String> keys = new ArrayList<>();+ int i = 1;+ while (true) {+ String key = p.getFirst("Tags.member." + i + ".Key");+ if (key == null) break;+ keys.add(key);+ i++;+ }+ service.removeTags(region, memberList(p, "LoadBalancerNames"), keys);+ return emptyResult("RemoveTags");+ }++ private Response describeTags(MultivaluedMap<String, String> p, String region) {+ Map<String, Map<String, String>> tags =+ service.describeTags(region, memberList(p, "LoadBalancerNames"));++ XmlBuilder xml = new XmlBuilder()+ .start("DescribeTagsResponse", AwsNamespaces.ELB_CLASSIC)+ .start("DescribeTagsResult")+ .start("TagDescriptions");+ for (Map.Entry<String, Map<String, String>> lbTags : tags.entrySet()) {+ xml.start("member")+ .elem("LoadBalancerName", lbTags.getKey())+ .start("Tags");+ for (Map.Entry<String, String> tag : lbTags.getValue().entrySet()) {+ xml.start("member").elem("Key", tag.getKey()).elem("Value", tag.getValue()).end("member");+ }+ xml.end("Tags").end("member");+ }+ xml.end("TagDescriptions")+ .end("DescribeTagsResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("DescribeTagsResponse");+ return ok(xml.build());+ }++ private Response describeAccountLimits() {+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeAccountLimitsResponse", AwsNamespaces.ELB_CLASSIC)+ .start("DescribeAccountLimitsResult")+ .start("Limits");+ for (Map.Entry<String, String> limit : ACCOUNT_LIMITS.entrySet()) {+ xml.start("member").elem("Name", limit.getKey()).elem("Max", limit.getValue()).end("member");+ }+ xml.end("Limits")+ .end("DescribeAccountLimitsResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("DescribeAccountLimitsResponse");+ return ok(xml.build());+ }++ // ── XML fragments ─────────────────────────────────────────────────────────++ private String loadBalancerDescriptionXml(ClassicLoadBalancer lb) {+ XmlBuilder xml = new XmlBuilder()+ .elem("LoadBalancerName", lb.getLoadBalancerName())+ .elem("DNSName", lb.getDnsName())+ .elem("CanonicalHostedZoneName", lb.getCanonicalHostedZoneName())+ .elem("CanonicalHostedZoneNameID", lb.getCanonicalHostedZoneNameId())+ .start("ListenerDescriptions");+ for (ClassicListener listener : lb.getListeners()) {+ xml.start("member")+ .start("Listener")+ .elem("Protocol", listener.getProtocol())+ .elem("LoadBalancerPort", String.valueOf(listener.getLoadBalancerPort()))+ .elem("InstanceProtocol", listener.getInstanceProtocol())+ .elem("InstancePort", String.valueOf(listener.getInstancePort()))+ .elem("SSLCertificateId", listener.getSslCertificateId())+ .end("Listener")+ .start("PolicyNames").end("PolicyNames")+ .end("member");+ }+ xml.end("ListenerDescriptions")+ // Floci implements no Classic policies; the element is present and empty, as it is on a+ // live load balancer that has none.+ .start("Policies")+ .start("AppCookieStickinessPolicies").end("AppCookieStickinessPolicies")+ .start("LBCookieStickinessPolicies").end("LBCookieStickinessPolicies")+ .start("OtherPolicies").end("OtherPolicies")+ .end("Policies")+ .start("BackendServerDescriptions").end("BackendServerDescriptions")+ .start("AvailabilityZones");+ for (String zone : lb.getAvailabilityZones()) {+ xml.elem("member", zone);+ }+ xml.end("AvailabilityZones").start("Subnets");+ for (String subnet : lb.getSubnets()) {+ xml.elem("member", subnet);+ }+ xml.end("Subnets")+ .elem("VPCId", lb.getVpcId())+ .start("Instances");+ for (String instanceId : lb.getInstanceIds()) {+ xml.start("member").elem("InstanceId", instanceId).end("member");+ }+ xml.end("Instances")+ .raw(healthCheckXml(lb.getHealthCheck()))+ .start("SourceSecurityGroup")+ .elem("OwnerAlias", lb.getSourceSecurityGroupOwnerAlias())+ .elem("GroupName", lb.getSourceSecurityGroupName())+ .end("SourceSecurityGroup")+ .start("SecurityGroups");+ for (String sg : lb.getSecurityGroups()) {+ xml.elem("member", sg);+ }+ xml.end("SecurityGroups")+ .elem("CreatedTime", lb.getCreatedTime() != null ? ISO_FMT.format(lb.getCreatedTime()) : null)+ .elem("Scheme", lb.getScheme());+ return xml.build();+ }++ private static String healthCheckXml(ClassicHealthCheck hc) {+ return new XmlBuilder()+ .start("HealthCheck")+ .elem("Target", hc.getTarget())+ .elem("Interval", String.valueOf(hc.getInterval()))+ .elem("Timeout", String.valueOf(hc.getTimeout()))+ .elem("UnhealthyThreshold", String.valueOf(hc.getUnhealthyThreshold()))+ .elem("HealthyThreshold", String.valueOf(hc.getHealthyThreshold()))+ .end("HealthCheck")+ .build();+ }++ private static String attributesXml(ClassicLoadBalancerAttributes a) {+ XmlBuilder xml = new XmlBuilder()+ .start("LoadBalancerAttributes")+ .start("CrossZoneLoadBalancing")+ .elem("Enabled", a.isCrossZoneLoadBalancingEnabled())+ .end("CrossZoneLoadBalancing")+ .start("AccessLog")+ .elem("Enabled", a.isAccessLogEnabled())+ .elem("S3BucketName", a.getAccessLogS3BucketName())+ .elem("S3BucketPrefix", a.getAccessLogS3BucketPrefix())+ .elem("EmitInterval", a.getAccessLogEmitInterval() != null+ ? String.valueOf(a.getAccessLogEmitInterval()) : null)+ .end("AccessLog")+ .start("ConnectionDraining")+ .elem("Enabled", a.isConnectionDrainingEnabled())+ .elem("Timeout", a.getConnectionDrainingTimeout() != null+ ? String.valueOf(a.getConnectionDrainingTimeout()) : null)+ .end("ConnectionDraining")+ .start("ConnectionSettings")+ .elem("IdleTimeout", a.getIdleTimeout() != null+ ? String.valueOf(a.getIdleTimeout()) : null)+ .end("ConnectionSettings")+ .start("AdditionalAttributes");+ for (Map.Entry<String, String> e : a.getAdditionalAttributes().entrySet()) {+ xml.start("member").elem("Key", e.getKey()).elem("Value", e.getValue()).end("member");+ }+ xml.end("AdditionalAttributes").end("LoadBalancerAttributes");+ return xml.build();+ }++ private static String instanceListResponse(String action, List<String> instanceIds) {+ XmlBuilder xml = new XmlBuilder()+ .start(action + "Response", AwsNamespaces.ELB_CLASSIC)+ .start(action + "Result")+ .start("Instances");+ for (String id : instanceIds) {+ xml.start("member").elem("InstanceId", id).end("member");+ }+ xml.end("Instances")+ .end(action + "Result")+ .raw(AwsQueryResponse.responseMetadata())+ .end(action + "Response");+ return xml.build();+ }++ private static String stringListResponse(String action, String listElement, List<String> values) {+ XmlBuilder xml = new XmlBuilder()+ .start(action + "Response", AwsNamespaces.ELB_CLASSIC)+ .start(action + "Result")+ .start(listElement);+ for (String value : values) {+ xml.elem("member", value);+ }+ xml.end(listElement)+ .end(action + "Result")+ .raw(AwsQueryResponse.responseMetadata())+ .end(action + "Response");+ return xml.build();+ }++ // ── Parsing helpers ───────────────────────────────────────────────────────++ private static String requireName(MultivaluedMap<String, String> p) {+ String name = p.getFirst("LoadBalancerName");+ if (name == null) {+ throw new AwsException("ValidationError",+ "LoadBalancerName is required for load balancer.", 400);+ }+ return name;+ }++ private static List<String> memberList(MultivaluedMap<String, String> p, String prefix) {+ List<String> result = new ArrayList<>();+ int i = 1;+ while (true) {+ String value = p.getFirst(prefix + ".member." + i);+ if (value == null) break;+ result.add(value);+ i++;+ }+ return result;+ }++ private static List<String> parseInstanceIds(MultivaluedMap<String, String> p) {+ List<String> result = new ArrayList<>();+ int i = 1;+ while (true) {+ String id = p.getFirst("Instances.member." + i + ".InstanceId");+ if (id == null) break;+ result.add(id);+ i++;+ }+ return result;+ }++ private static List<ClassicListener> parseListeners(MultivaluedMap<String, String> p, String prefix) {+ List<ClassicListener> result = new ArrayList<>();+ int i = 1;+ while (true) {+ String base = prefix + ".member." + i + ".";+ String protocol = p.getFirst(base + "Protocol");+ String lbPort = p.getFirst(base + "LoadBalancerPort");+ if (protocol == null && lbPort == null) break;+ ClassicListener listener = new ClassicListener();+ listener.setProtocol(protocol);+ listener.setLoadBalancerPort(intOrNull(lbPort));+ listener.setInstanceProtocol(p.getFirst(base + "InstanceProtocol"));+ listener.setInstancePort(intOrNull(p.getFirst(base + "InstancePort")));+ listener.setSslCertificateId(p.getFirst(base + "SSLCertificateId"));+ result.add(listener);+ i++;+ }+ return result;+ }++ private static Map<String, String> parseTags(MultivaluedMap<String, String> p) {+ Map<String, String> tags = 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");+ tags.put(key, value != null ? value : "");+ i++;+ }+ return tags;+ }++ private static Integer intOrNull(String s) {+ if (s == null || s.isEmpty()) return null;+ try {+ return Integer.valueOf(s);+ } catch (NumberFormatException e) {+ throw new AwsException("ValidationError", "'" + s + "' is not a valid integer.", 400);+ }+ }++ private static Boolean boolOrNull(String s) {+ if (s == null || s.isEmpty()) return null;+ return Boolean.valueOf(s);+ }++ private static Response ok(String xml) {+ return Response.ok(xml).type(MediaType.APPLICATION_XML).build();+ }++ private static Response emptyResult(String action) {+ return ok(new XmlBuilder()+ .start(action + "Response", AwsNamespaces.ELB_CLASSIC)+ .start(action + "Result").end(action + "Result")+ .raw(AwsQueryResponse.responseMetadata())+ .end(action + "Response")+ .build());+ }++ private static Response xmlError(String code, String message, int status) {+ String xml = new XmlBuilder()+ .start("ErrorResponse", AwsNamespaces.ELB_CLASSIC)+ .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();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicService.java b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicService.javanew file mode 100644index 0000000000..40dac4d04c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicService.java@@ -0,0 +1,532 @@+package io.github.hectorvent.floci.services.elb;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.dns.EmbeddedDnsServer;+import io.github.hectorvent.floci.core.storage.StorageBackedMap;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Subnet;+import io.github.hectorvent.floci.services.elb.model.ClassicHealthCheck;+import io.github.hectorvent.floci.services.elb.model.ClassicListener;+import io.github.hectorvent.floci.services.elb.model.ClassicLoadBalancer;+import jakarta.annotation.PostConstruct;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.security.SecureRandom;+import java.time.Instant;+import java.util.ArrayList;+import java.util.Collection;+import java.util.LinkedHashMap;+import java.util.LinkedHashSet;+import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.concurrent.ConcurrentHashMap;+import java.util.stream.Collectors;++/**+ * State and behaviour for Classic (2012-06-01) Elastic Load Balancing.+ *+ * <p>Kept apart from {@code ElbV2Service} on purpose. The two APIs share an endpoint host and a+ * credential scope but not a data model: a Classic load balancer is keyed by name and has no ARN,+ * carries its listeners inline rather than through listener and target-group resources, and holds+ * one structured attribute record instead of a key/value list. Answering a Classic request from+ * the v2 store is exactly the defect this class exists to remove.+ *+ * <p>Scope is deliberately the operations the AWS provider drives for {@code aws_elb} and for an+ * Auto Scaling group attached to one. Stickiness and backend-server policies are not implemented;+ * {@code ElbClassicQueryHandler} answers those with {@code UnsupportedOperation} rather than+ * inventing a result.+ */+@ApplicationScoped+public class ElbClassicService {++ /** The hosted zone ID AWS reports for Classic load balancers; fixed per region on AWS too. */+ private static final String CANONICAL_HOSTED_ZONE_ID = "Z35SXDOTRQ7X7K";++ private static final SecureRandom RANDOM = new SecureRandom();++ private final Ec2Service ec2Service;+ private final ElbClassicHealthChecker healthChecker;+ private final StorageFactory storageFactory;+ private final EmulatorConfig config;++ // region → load balancer name → record+ private Map<String, Map<String, ClassicLoadBalancer>> loadBalancers = new ConcurrentHashMap<>();++ @Inject+ public ElbClassicService(Ec2Service ec2Service,+ ElbClassicHealthChecker healthChecker,+ StorageFactory storageFactory,+ EmulatorConfig config) {+ this.ec2Service = ec2Service;+ this.healthChecker = healthChecker;+ this.storageFactory = storageFactory;+ this.config = config;+ }++ @PostConstruct+ void initializeStorage() {+ if (storageFactory == null) {+ return;+ }+ this.loadBalancers = new StorageBackedMap<>(storageFactory.create("elb", "elb-load-balancers.json",+ new TypeReference<Map<String, Map<String, ClassicLoadBalancer>>>() {}));+ for (Map.Entry<String, Map<String, ClassicLoadBalancer>> entry+ : new ArrayList<>(loadBalancers.entrySet())) {+ if (!(entry.getValue() instanceof ConcurrentHashMap)) {+ loadBalancers.put(entry.getKey(), new ConcurrentHashMap<>(entry.getValue()));+ }+ }+ }++ /**+ * Restarts health checking for load balancers restored from disk. Called from+ * {@code EmulatorLifecycle} once the bean is constructed, like {@code ElbV2Service} does —+ * nothing reachable from {@link #initializeStorage()} may touch an injected collaborator.+ */+ public void restorePersistedRuntime() {+ for (Map<String, ClassicLoadBalancer> regionLbs : loadBalancers.values()) {+ for (ClassicLoadBalancer lb : regionLbs.values()) {+ healthChecker.startMonitoring(lb);+ healthChecker.registerInstances(lb, lb.getInstanceIds());+ }+ }+ }++ // ── Load balancers ────────────────────────────────────────────────────────++ public ClassicLoadBalancer createLoadBalancer(String region, String name,+ List<ClassicListener> listeners,+ List<String> availabilityZones,+ List<String> subnets,+ List<String> securityGroups,+ String scheme,+ Map<String, String> tags) {+ validateName(name);+ if (listeners == null || listeners.isEmpty()) {+ // Listeners is a required member of CreateAccessPointInput, and unlike LoadBalancerName+ // the model gives its member shape required fields — an empty list cannot be honoured.+ throw new AwsException("ValidationError",+ "At least one listener must be specified.", 400);+ }+ for (ClassicListener listener : listeners) {+ validateListener(listener);+ }++ Map<String, ClassicLoadBalancer> regionLbs =+ loadBalancers.computeIfAbsent(region, k -> new ConcurrentHashMap<>());+ if (regionLbs.containsKey(name)) {+ throw new AwsException("DuplicateLoadBalancerName",+ "Load balancer named " + name + " already exists and is not compatible with the "+ + "requested configuration.", 400);+ }++ String id = randomHex();+ String dnsName = name + "-" + id + ".elb." + dnsSuffix();++ ClassicLoadBalancer lb = new ClassicLoadBalancer();+ lb.setLoadBalancerName(name);+ lb.setRegion(region);+ lb.setDnsName(dnsName);+ lb.setCanonicalHostedZoneName(dnsName);+ lb.setCanonicalHostedZoneNameId(CANONICAL_HOSTED_ZONE_ID);+ lb.setScheme(scheme != null && !scheme.isBlank() ? scheme : "internet-facing");+ lb.setCreatedTime(Instant.now());+ lb.setListeners(new ArrayList<>(listeners));+ lb.setSecurityGroups(securityGroups != null ? new ArrayList<>(securityGroups) : new ArrayList<>());+ lb.setHealthCheck(ClassicHealthCheck.defaults());+ if (tags != null && !tags.isEmpty()) {+ lb.setTags(new LinkedHashMap<>(tags));+ }++ if (subnets != null && !subnets.isEmpty()) {+ lb.setSubnets(new ArrayList<>(subnets));+ Map<String, Subnet> byId = resolveSubnets(region, subnets);+ lb.setVpcId(singleVpcId(byId.values()));+ lb.setAvailabilityZones(byId.values().stream()+ .map(Subnet::getAvailabilityZone)+ .distinct()+ .collect(Collectors.toCollection(ArrayList::new)));+ } else if (availabilityZones != null) {+ lb.setAvailabilityZones(new ArrayList<>(availabilityZones));+ }++ regionLbs.put(name, lb);+ loadBalancers.put(region, regionLbs);+ healthChecker.startMonitoring(lb);+ return lb;+ }++ public List<ClassicLoadBalancer> describeLoadBalancers(String region, List<String> names) {+ Map<String, ClassicLoadBalancer> regionLbs = loadBalancers.getOrDefault(region, Map.of());+ if (names == null || names.isEmpty()) {+ return new ArrayList<>(regionLbs.values());+ }+ List<ClassicLoadBalancer> result = new ArrayList<>();+ for (String name : names) {+ ClassicLoadBalancer lb = regionLbs.get(name);+ if (lb == null) {+ throw new AwsException("LoadBalancerNotFound",+ "There is no ACTIVE Load Balancer named '" + name + "'", 400);+ }+ result.add(lb);+ }+ return result;+ }++ /** Deletes a load balancer. Deleting one that does not exist succeeds, as it does on AWS. */+ public void deleteLoadBalancer(String region, String name) {+ Map<String, ClassicLoadBalancer> regionLbs = loadBalancers.get(region);+ if (regionLbs == null) {+ return;+ }+ if (regionLbs.remove(name) != null) {+ healthChecker.stopMonitoring(region, name);+ loadBalancers.put(region, regionLbs);+ }+ }++ public boolean hasLoadBalancer(String region, String name) {+ return loadBalancers.getOrDefault(region, Map.of()).containsKey(name);+ }++ public ClassicLoadBalancer requireLoadBalancer(String region, String name) {+ ClassicLoadBalancer lb = loadBalancers.getOrDefault(region, Map.of()).get(name);+ if (lb == null) {+ throw new AwsException("LoadBalancerNotFound",+ "There is no ACTIVE Load Balancer named '" + name + "'", 400);+ }+ return lb;+ }++ // ── Listeners ─────────────────────────────────────────────────────────────++ public void createLoadBalancerListeners(String region, String name, List<ClassicListener> listeners) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ for (ClassicListener listener : listeners) {+ validateListener(listener);+ }+ for (ClassicListener listener : listeners) {+ ClassicListener existing = lb.getListeners().stream()+ .filter(l -> l.getLoadBalancerPort().equals(listener.getLoadBalancerPort()))+ .findFirst()+ .orElse(null);+ if (existing != null) {+ // AWS accepts a repeat of an identical listener and rejects a conflicting one.+ if (!sameListener(existing, listener)) {+ throw new AwsException("DuplicateListener",+ "A listener already exists for " + name + " with LoadBalancerPort "+ + listener.getLoadBalancerPort()+ + ", but with a different InstancePort, Protocol, or "+ + "SSLCertificateId", 400);+ }+ continue;+ }+ lb.getListeners().add(listener);+ }+ persist(region);+ }++ public void deleteLoadBalancerListeners(String region, String name, List<Integer> loadBalancerPorts) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ lb.getListeners().removeIf(l -> loadBalancerPorts.contains(l.getLoadBalancerPort()));+ persist(region);+ }++ // ── Health ────────────────────────────────────────────────────────────────++ public ClassicHealthCheck configureHealthCheck(String region, String name, ClassicHealthCheck healthCheck) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ validateHealthCheck(healthCheck);+ lb.setHealthCheck(healthCheck);+ persist(region);+ healthChecker.healthCheckChanged(lb);+ return healthCheck;+ }++ public List<String> registerInstances(String region, String name, List<String> instanceIds) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ for (String id : instanceIds) {+ if (!lb.getInstanceIds().contains(id)) {+ lb.getInstanceIds().add(id);+ }+ }+ persist(region);+ healthChecker.registerInstances(lb, instanceIds);+ return List.copyOf(lb.getInstanceIds());+ }++ public List<String> deregisterInstances(String region, String name, List<String> instanceIds) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ lb.getInstanceIds().removeAll(instanceIds);+ persist(region);+ healthChecker.deregisterInstances(region, name, instanceIds);+ return List.copyOf(lb.getInstanceIds());+ }++ /** The health of each requested instance, or of every registered instance when none is named. */+ public Map<String, ElbClassicHealthChecker.InstanceHealth> describeInstanceHealth(+ String region, String name, List<String> instanceIds) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ List<String> wanted = instanceIds == null || instanceIds.isEmpty()+ ? lb.getInstanceIds()+ : instanceIds;+ Map<String, ElbClassicHealthChecker.InstanceHealth> result = new LinkedHashMap<>();+ for (String id : wanted) {+ if (!lb.getInstanceIds().contains(id)) {+ throw new AwsException("InvalidInstance",+ "Could not find EC2 instance " + id + ".", 400);+ }+ result.put(id, healthChecker.getHealth(region, name, id));+ }+ return result;+ }++ // ── Attributes, zones, subnets, security groups ───────────────────────────++ public ClassicLoadBalancer modifyLoadBalancerAttributes(String region, String name,+ AttributeUpdate update) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ update.applyTo(lb.getAttributes());+ persist(region);+ return lb;+ }++ /** The subset of {@code LoadBalancerAttributes} a request actually carried; unset stays unset. */+ public record AttributeUpdate(Boolean crossZoneEnabled,+ Boolean accessLogEnabled,+ String accessLogS3BucketName,+ String accessLogS3BucketPrefix,+ Integer accessLogEmitInterval,+ Boolean connectionDrainingEnabled,+ Integer connectionDrainingTimeout,+ Integer idleTimeout,+ Map<String, String> additionalAttributes) {++ void applyTo(io.github.hectorvent.floci.services.elb.model.ClassicLoadBalancerAttributes attrs) {+ if (crossZoneEnabled != null) attrs.setCrossZoneLoadBalancingEnabled(crossZoneEnabled);+ if (accessLogEnabled != null) attrs.setAccessLogEnabled(accessLogEnabled);+ if (accessLogS3BucketName != null) attrs.setAccessLogS3BucketName(accessLogS3BucketName);+ if (accessLogS3BucketPrefix != null) attrs.setAccessLogS3BucketPrefix(accessLogS3BucketPrefix);+ if (accessLogEmitInterval != null) attrs.setAccessLogEmitInterval(accessLogEmitInterval);+ if (connectionDrainingEnabled != null) attrs.setConnectionDrainingEnabled(connectionDrainingEnabled);+ if (connectionDrainingTimeout != null) attrs.setConnectionDrainingTimeout(connectionDrainingTimeout);+ if (idleTimeout != null) attrs.setIdleTimeout(idleTimeout);+ if (additionalAttributes != null && !additionalAttributes.isEmpty()) {+ attrs.getAdditionalAttributes().putAll(additionalAttributes);+ }+ }+ }++ public List<String> applySecurityGroups(String region, String name, List<String> securityGroups) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ lb.setSecurityGroups(new ArrayList<>(securityGroups));+ persist(region);+ return List.copyOf(lb.getSecurityGroups());+ }++ public List<String> attachToSubnets(String region, String name, List<String> subnets) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ resolveSubnets(region, subnets);+ for (String subnet : subnets) {+ if (!lb.getSubnets().contains(subnet)) {+ lb.getSubnets().add(subnet);+ }+ }+ refreshZonesFromSubnets(region, lb);+ persist(region);+ return List.copyOf(lb.getSubnets());+ }++ public List<String> detachFromSubnets(String region, String name, List<String> subnets) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ lb.getSubnets().removeAll(subnets);+ refreshZonesFromSubnets(region, lb);+ persist(region);+ return List.copyOf(lb.getSubnets());+ }++ public List<String> enableAvailabilityZones(String region, String name, List<String> zones) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ for (String zone : zones) {+ if (!lb.getAvailabilityZones().contains(zone)) {+ lb.getAvailabilityZones().add(zone);+ }+ }+ persist(region);+ return List.copyOf(lb.getAvailabilityZones());+ }++ public List<String> disableAvailabilityZones(String region, String name, List<String> zones) {+ ClassicLoadBalancer lb = requireLoadBalancer(region, name);+ lb.getAvailabilityZones().removeAll(zones);+ persist(region);+ return List.copyOf(lb.getAvailabilityZones());+ }++ // ── Tags ──────────────────────────────────────────────────────────────────++ public void addTags(String region, List<String> names, Map<String, String> tags) {+ for (String name : names) {+ requireLoadBalancer(region, name).getTags().putAll(tags);+ }+ persist(region);+ }++ public void removeTags(String region, List<String> names, Collection<String> tagKeys) {+ for (String name : names) {+ requireLoadBalancer(region, name).getTags().keySet().removeAll(tagKeys);+ }+ persist(region);+ }++ public Map<String, Map<String, String>> describeTags(String region, List<String> names) {+ Map<String, Map<String, String>> result = new LinkedHashMap<>();+ for (String name : names) {+ result.put(name, Map.copyOf(requireLoadBalancer(region, name).getTags()));+ }+ return result;+ }++ // ── Internals ─────────────────────────────────────────────────────────────++ private void persist(String region) {+ Map<String, ClassicLoadBalancer> regionLbs = loadBalancers.get(region);+ if (regionLbs != null) {+ loadBalancers.put(region, regionLbs);+ }+ }++ private void refreshZonesFromSubnets(String region, ClassicLoadBalancer lb) {+ if (lb.getSubnets().isEmpty()) {+ lb.setAvailabilityZones(new ArrayList<>());+ return;+ }+ Map<String, Subnet> byId = resolveSubnets(region, lb.getSubnets());+ lb.setVpcId(singleVpcId(byId.values()));+ lb.setAvailabilityZones(byId.values().stream()+ .map(Subnet::getAvailabilityZone)+ .distinct()+ .collect(Collectors.toCollection(ArrayList::new)));+ }++ private Map<String, Subnet> resolveSubnets(String region, List<String> subnetIds) {+ Map<String, Subnet> byId = ec2Service.describeSubnets(region, subnetIds, Map.of()).stream()+ .collect(Collectors.toMap(Subnet::getSubnetId, s -> s, (l, r) -> l,+ LinkedHashMap::new));+ for (String subnetId : subnetIds) {+ if (!byId.containsKey(subnetId)) {+ throw new AwsException("SubnetNotFound",+ "The subnet ID '" + subnetId + "' does not exist", 400);+ }+ }+ return byId;+ }++ private static String singleVpcId(Collection<Subnet> subnets) {+ Set<String> vpcIds = subnets.stream()+ .map(Subnet::getVpcId)+ .collect(Collectors.toCollection(LinkedHashSet::new));+ if (vpcIds.size() > 1) {+ // CreateLoadBalancer's own Errors table documents InvalidConfigurationRequest at 409,+ // not 400: a client that retries on 409 but fails hard on 400 needs the real status.+ throw new AwsException("InvalidConfigurationRequest",+ "All subnets must belong to the same VPC.", 409);+ }+ return vpcIds.isEmpty() ? null : vpcIds.iterator().next();+ }++ private String dnsSuffix() {+ if (config == null) {+ return EmbeddedDnsServer.DEFAULT_SUFFIX;+ }+ return config.hostname().orElse(EmbeddedDnsServer.DEFAULT_SUFFIX);+ }++ private static String randomHex() {+ byte[] bytes = new byte[5];+ RANDOM.nextBytes(bytes);+ StringBuilder sb = new StringBuilder();+ for (byte b : bytes) {+ sb.append(String.format("%02x", b));+ }+ return sb.toString();+ }++ /**+ * Rejects a load balancer name AWS would reject.+ *+ * <p>{@code LoadBalancerName} is a required member, and required means present — the model+ * declares no {@code min} on {@code AccessPointName}, so an empty string is a missing name+ * only in the sense that the member was not supplied. The 32-character ceiling and the+ * alphanumeric-and-hyphen rule are AWS's documented constraints for Classic names.+ */+ private static void validateName(String name) {+ if (name == null) {+ throw new AwsException("ValidationError",+ "LoadBalancerName is required for load balancer.", 400);+ }+ if (name.isEmpty() || name.length() > 32) {+ throw new AwsException("ValidationError",+ "LoadBalancerName must be between 1 and 32 characters long.", 400);+ }+ if (!name.matches("[a-zA-Z0-9-]+")) {+ throw new AwsException("ValidationError",+ "LoadBalancerName '" + name + "' contains invalid characters. Use alphanumeric "+ + "characters and hyphens.", 400);+ }+ if (name.startsWith("-") || name.endsWith("-")) {+ throw new AwsException("ValidationError",+ "LoadBalancerName '" + name + "' cannot start or end with a hyphen.", 400);+ }+ }++ private static void validateListener(ClassicListener listener) {+ if (listener.getProtocol() == null || listener.getLoadBalancerPort() == null+ || listener.getInstancePort() == null) {+ throw new AwsException("ValidationError",+ "Protocol, LoadBalancerPort and InstancePort are required for each listener.", 400);+ }+ if (listener.getInstancePort() < 1 || listener.getInstancePort() > 65535) {+ throw new AwsException("ValidationError",+ "InstancePort must be between 1 and 65535.", 400);+ }+ }++ /**+ * Rejects a health check outside the ranges the model declares — {@code Interval} 5–300,+ * {@code Timeout} 2–60, both thresholds 2–10 — and one with no {@code Target}, which the model+ * marks required.+ */+ private static void validateHealthCheck(ClassicHealthCheck hc) {+ if (hc.getTarget() == null || hc.getTarget().isBlank()) {+ throw new AwsException("ValidationError",+ "HealthCheck.Target is required.", 400);+ }+ requireRange("HealthCheck.Interval", hc.getInterval(), 5, 300);+ requireRange("HealthCheck.Timeout", hc.getTimeout(), 2, 60);+ requireRange("HealthCheck.UnhealthyThreshold", hc.getUnhealthyThreshold(), 2, 10);+ requireRange("HealthCheck.HealthyThreshold", hc.getHealthyThreshold(), 2, 10);+ }++ private static void requireRange(String member, Integer value, int min, int max) {+ if (value == null) {+ throw new AwsException("ValidationError", member + " is required.", 400);+ }+ if (value < min || value > max) {+ throw new AwsException("ValidationError",+ member + " must be between " + min + " and " + max + ".", 400);+ }+ }++ private static boolean sameListener(ClassicListener a, ClassicListener b) {+ return java.util.Objects.equals(a.getProtocol(), b.getProtocol())+ && java.util.Objects.equals(a.getInstancePort(), b.getInstancePort())+ && java.util.Objects.equals(a.getInstanceProtocol(), b.getInstanceProtocol())+ && java.util.Objects.equals(a.getSslCertificateId(), b.getSslCertificateId());+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicHealthCheck.java b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicHealthCheck.javanew file mode 100644index 0000000000..ac03e72e41--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicHealthCheck.java@@ -0,0 +1,50 @@+package io.github.hectorvent.floci.services.elb.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * The {@code HealthCheck} shape of the Classic (2012-06-01) load balancing API.+ *+ * <p>Every member is required by the model, so a stored health check is always complete. The+ * defaults applied on {@code CreateLoadBalancer} are AWS's own documented defaults, which is+ * what a Classic load balancer reports before {@code ConfigureHealthCheck} is ever called.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class ClassicHealthCheck {++ /** AWS's default health check for a newly created Classic load balancer. */+ public static ClassicHealthCheck defaults() {+ ClassicHealthCheck hc = new ClassicHealthCheck();+ hc.setTarget("TCP:80");+ hc.setInterval(30);+ hc.setTimeout(5);+ hc.setUnhealthyThreshold(2);+ hc.setHealthyThreshold(10);+ return hc;+ }++ private String target;+ private Integer interval;+ private Integer timeout;+ private Integer unhealthyThreshold;+ private Integer healthyThreshold;++ public ClassicHealthCheck() {}++ public String getTarget() { return target; }+ public void setTarget(String target) { this.target = target; }++ public Integer getInterval() { return interval; }+ public void setInterval(Integer interval) { this.interval = interval; }++ public Integer getTimeout() { return timeout; }+ public void setTimeout(Integer timeout) { this.timeout = timeout; }++ public Integer getUnhealthyThreshold() { return unhealthyThreshold; }+ public void setUnhealthyThreshold(Integer unhealthyThreshold) { this.unhealthyThreshold = unhealthyThreshold; }++ public Integer getHealthyThreshold() { return healthyThreshold; }+ public void setHealthyThreshold(Integer healthyThreshold) { this.healthyThreshold = healthyThreshold; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicListener.java b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicListener.javanew file mode 100644index 0000000000..bdacb069c7--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicListener.java@@ -0,0 +1,39 @@+package io.github.hectorvent.floci.services.elb.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * A Classic (2012-06-01) load balancer listener.+ *+ * <p>Mirrors the {@code Listener} shape of the {@code elasticloadbalancing} 2012-06-01 model:+ * {@code Protocol}, {@code LoadBalancerPort} and {@code InstancePort} are required members,+ * {@code InstanceProtocol} and {@code SSLCertificateId} are optional.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class ClassicListener {++ private String protocol;+ private Integer loadBalancerPort;+ private String instanceProtocol;+ private Integer instancePort;+ private String sslCertificateId;++ public ClassicListener() {}++ public String getProtocol() { return protocol; }+ public void setProtocol(String protocol) { this.protocol = protocol; }++ public Integer getLoadBalancerPort() { return loadBalancerPort; }+ public void setLoadBalancerPort(Integer loadBalancerPort) { this.loadBalancerPort = loadBalancerPort; }++ public String getInstanceProtocol() { return instanceProtocol; }+ public void setInstanceProtocol(String instanceProtocol) { this.instanceProtocol = instanceProtocol; }++ public Integer getInstancePort() { return instancePort; }+ public void setInstancePort(Integer instancePort) { this.instancePort = instancePort; }++ public String getSslCertificateId() { return sslCertificateId; }+ public void setSslCertificateId(String sslCertificateId) { this.sslCertificateId = sslCertificateId; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicLoadBalancer.java b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicLoadBalancer.javanew file mode 100644index 0000000000..fecb5e5e6b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicLoadBalancer.java@@ -0,0 +1,100 @@+package io.github.hectorvent.floci.services.elb.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;++/**+ * A Classic (2012-06-01) load balancer — the {@code LoadBalancerDescription} shape.+ *+ * <p>Deliberately not the ELBv2 {@code LoadBalancer}: a Classic load balancer has no ARN, no+ * target groups, and is addressed by name for the whole life of the record. Sharing the v2 model+ * is what produced the defect this type exists to fix.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class ClassicLoadBalancer {++ private String loadBalancerName;+ private String dnsName;+ private String canonicalHostedZoneName;+ private String canonicalHostedZoneNameId;+ private String scheme;+ private String vpcId;+ private String region;+ private Instant createdTime;++ private List<ClassicListener> listeners = new ArrayList<>();+ private List<String> availabilityZones = new ArrayList<>();+ private List<String> subnets = new ArrayList<>();+ private List<String> securityGroups = new ArrayList<>();+ private List<String> instanceIds = new ArrayList<>();++ private String sourceSecurityGroupOwnerAlias;+ private String sourceSecurityGroupName;++ private ClassicHealthCheck healthCheck = ClassicHealthCheck.defaults();+ private ClassicLoadBalancerAttributes attributes = new ClassicLoadBalancerAttributes();+ private Map<String, String> tags = new LinkedHashMap<>();++ public ClassicLoadBalancer() {}++ public String getLoadBalancerName() { return loadBalancerName; }+ public void setLoadBalancerName(String v) { this.loadBalancerName = v; }++ public String getDnsName() { return dnsName; }+ public void setDnsName(String v) { this.dnsName = v; }++ public String getCanonicalHostedZoneName() { return canonicalHostedZoneName; }+ public void setCanonicalHostedZoneName(String v) { this.canonicalHostedZoneName = v; }++ public String getCanonicalHostedZoneNameId() { return canonicalHostedZoneNameId; }+ public void setCanonicalHostedZoneNameId(String v) { this.canonicalHostedZoneNameId = v; }++ public String getScheme() { return scheme; }+ public void setScheme(String v) { this.scheme = v; }++ public String getVpcId() { return vpcId; }+ public void setVpcId(String v) { this.vpcId = v; }++ public String getRegion() { return region; }+ public void setRegion(String v) { this.region = v; }++ public Instant getCreatedTime() { return createdTime; }+ public void setCreatedTime(Instant v) { this.createdTime = v; }++ public List<ClassicListener> getListeners() { return listeners; }+ public void setListeners(List<ClassicListener> v) { this.listeners = v; }++ public List<String> getAvailabilityZones() { return availabilityZones; }+ public void setAvailabilityZones(List<String> v) { this.availabilityZones = v; }++ public List<String> getSubnets() { return subnets; }+ public void setSubnets(List<String> v) { this.subnets = v; }++ public List<String> getSecurityGroups() { return securityGroups; }+ public void setSecurityGroups(List<String> v) { this.securityGroups = v; }++ public List<String> getInstanceIds() { return instanceIds; }+ public void setInstanceIds(List<String> v) { this.instanceIds = v; }++ public String getSourceSecurityGroupOwnerAlias() { return sourceSecurityGroupOwnerAlias; }+ public void setSourceSecurityGroupOwnerAlias(String v) { this.sourceSecurityGroupOwnerAlias = v; }++ public String getSourceSecurityGroupName() { return sourceSecurityGroupName; }+ public void setSourceSecurityGroupName(String v) { this.sourceSecurityGroupName = v; }++ public ClassicHealthCheck getHealthCheck() { return healthCheck; }+ public void setHealthCheck(ClassicHealthCheck v) { this.healthCheck = v; }++ public ClassicLoadBalancerAttributes getAttributes() { return attributes; }+ public void setAttributes(ClassicLoadBalancerAttributes v) { this.attributes = v; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> v) { this.tags = v; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicLoadBalancerAttributes.java b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicLoadBalancerAttributes.javanew file mode 100644index 0000000000..2c44599cbb--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/elb/model/ClassicLoadBalancerAttributes.java@@ -0,0 +1,66 @@+package io.github.hectorvent.floci.services.elb.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.LinkedHashMap;+import java.util.Map;++/**+ * The {@code LoadBalancerAttributes} shape of the Classic (2012-06-01) load balancing API.+ *+ * <p>Classic attributes are a fixed structure rather than the ELBv2 key/value list, so they are+ * modelled as fields. Only the four documented sub-structures plus {@code AdditionalAttributes}+ * exist; anything else a caller sends is carried in {@code additionalAttributes} unchanged.+ *+ * <p>The initial values are AWS's own defaults for a freshly created Classic load balancer:+ * cross-zone off, access logging off, connection draining off with a 300 second timeout, and a+ * 60 second idle timeout.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class ClassicLoadBalancerAttributes {++ private boolean crossZoneLoadBalancingEnabled = false;++ private boolean accessLogEnabled = false;+ private String accessLogS3BucketName;+ private String accessLogS3BucketPrefix;+ private Integer accessLogEmitInterval = 60;++ private boolean connectionDrainingEnabled = false;+ private Integer connectionDrainingTimeout = 300;++ private Integer idleTimeout = 60;++ private Map<String, String> additionalAttributes = new LinkedHashMap<>();++ public ClassicLoadBalancerAttributes() {}++ public boolean isCrossZoneLoadBalancingEnabled() { return crossZoneLoadBalancingEnabled; }+ public void setCrossZoneLoadBalancingEnabled(boolean v) { this.crossZoneLoadBalancingEnabled = v; }++ public boolean isAccessLogEnabled() { return accessLogEnabled; }+ public void setAccessLogEnabled(boolean v) { this.accessLogEnabled = v; }++ public String getAccessLogS3BucketName() { return accessLogS3BucketName; }+ public void setAccessLogS3BucketName(String v) { this.accessLogS3BucketName = v; }++ public String getAccessLogS3BucketPrefix() { return accessLogS3BucketPrefix; }+ public void setAccessLogS3BucketPrefix(String v) { this.accessLogS3BucketPrefix = v; }++ public Integer getAccessLogEmitInterval() { return accessLogEmitInterval; }+ public void setAccessLogEmitInterval(Integer v) { this.accessLogEmitInterval = v; }++ public boolean isConnectionDrainingEnabled() { return connectionDrainingEnabled; }+ public void setConnectionDrainingEnabled(boolean v) { this.connectionDrainingEnabled = v; }++ public Integer getConnectionDrainingTimeout() { return connectionDrainingTimeout; }+ public void setConnectionDrainingTimeout(Integer v) { this.connectionDrainingTimeout = v; }++ public Integer getIdleTimeout() { return idleTimeout; }+ public void setIdleTimeout(Integer v) { this.idleTimeout = v; }++ public Map<String, String> getAdditionalAttributes() { return additionalAttributes; }+ public void setAdditionalAttributes(Map<String, String> v) { this.additionalAttributes = v; }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 4ee259e915..bf234d13b3 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -67,6 +67,7 @@ quarkus:- --initialize-at-run-time=io.github.hectorvent.floci.services.cloudfront.CloudFrontService- --initialize-at-run-time=io.github.hectorvent.floci.services.emr.EmrService- --initialize-at-run-time=io.github.hectorvent.floci.services.elasticbeanstalk.ElasticBeanstalkService+ - --initialize-at-run-time=io.github.hectorvent.floci.services.elb.ElbClassicService- --initialize-at-run-time=graphql.util.IdGenerator- --initialize-at-run-time=io.github.hectorvent.floci.services.lambda.launcher.LambdaExecutionRoleCredentials# snappy-java (Firehose Snappy/HADOOP_SNAPPY delivery) extracts and loads a@@ -488,6 +489,9 @@ floci:keep-running-on-shutdown: falsedag-sync-interval-seconds: 30install-requirements: true+ elb:+ enabled: true+ mock: falseelbv2:enabled: truemock: falsediff --git a/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java b/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.javaindex 0590a5e18c..aa2c6c6de6 100644--- a/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java+++ b/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java@@ -60,6 +60,7 @@ class EmulatorLifecycleTest {@Mock private EmulatorConfig.ServicesConfig servicesConfig;@Mock private EmulatorConfig.Ec2ServiceConfig ec2ServiceConfig;@Mock private EmulatorConfig.ElbV2ServiceConfig elbv2ServiceConfig;+ @Mock private EmulatorConfig.ElbServiceConfig elbServiceConfig;@Mock private IamService iamService;@Mock private EmulatorConfig.ElastiCacheServiceConfig elastiCacheServiceConfig;@Mock private ElastiCacheService elastiCacheService;@@ -77,6 +78,7 @@ class EmulatorLifecycleTest {@Mock private io.github.hectorvent.floci.services.kinesisanalytics.container.FlinkContainerManager flinkContainerManager;@Mock private RdsService rdsService;@Mock private io.github.hectorvent.floci.services.elbv2.ElbV2Service elbV2Service;+ @Mock private io.github.hectorvent.floci.services.elb.ElbClassicService elbClassicService;@Mock private InitializationHooksRunner initializationHooksRunner;@Mock private SqsEventSourcePoller sqsPoller;@Mock private KinesisEventSourcePoller kinesisPoller;@@ -102,6 +104,8 @@ class EmulatorLifecycleTest {Mockito.lenient().when(elbv2ServiceConfig.enabled()).thenReturn(false);Mockito.lenient().when(servicesConfig.elasticache()).thenReturn(elastiCacheServiceConfig);Mockito.lenient().when(elastiCacheServiceConfig.enabled()).thenReturn(false);+ Mockito.lenient().when(servicesConfig.elb()).thenReturn(elbServiceConfig);+ Mockito.lenient().when(elbServiceConfig.enabled()).thenReturn(false);Mockito.lenient().when(config.tls()).thenReturn(tlsConfig);Mockito.lenient().when(tlsConfig.enabled()).thenReturn(false);Mockito.lenient().when(config.port()).thenReturn(4566);@@ -113,7 +117,7 @@ class EmulatorLifecycleTest {elastiCacheProxyManager, rdsContainerManager, rdsProxyManager,memoryDbContainerManager, memoryDbProxyManager,docDbContainerManager, neptuneContainerManager, neptuneProxyManager,- rabbitMqManager, flinkContainerManager, rdsService, elbV2Service,+ rabbitMqManager, flinkContainerManager, rdsService, elbV2Service, elbClassicService,initializationHooksRunner, sqsPoller, kinesisPoller, dynamodbStreamsPoller,pipesService, ec2MetadataServer, ecrRegistryManager, flociUiManager, initLifecycleState,schemaCreationWorker, containerTeardowns, persistentPathValidator);diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.javaindex b8cca1b6d1..71816bebc3 100644--- a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.java@@ -11,6 +11,7 @@ import io.github.hectorvent.floci.services.ec2.model.LaunchTemplate;import io.github.hectorvent.floci.services.ec2.model.LaunchTemplateData;import io.github.hectorvent.floci.services.ec2.model.Reservation;import io.github.hectorvent.floci.services.ec2.model.Tag;+import io.github.hectorvent.floci.services.elb.ElbClassicService;import io.github.hectorvent.floci.services.elbv2.ElbV2Service;import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;import io.github.hectorvent.floci.services.elbv2.model.TargetHealth;@@ -386,7 +387,7 @@ class AutoScalingReconcilerTest {ElbV2Service elbV2Service = mock(ElbV2Service.class);SsmCommandService ssmCommandService = mock(SsmCommandService.class);AutoScalingReconciler reconciler = new AutoScalingReconciler(- asgService, ec2Service, elbV2Service, ssmCommandService);+ asgService, ec2Service, elbV2Service, null, ssmCommandService);AutoScalingGroup asg = new AutoScalingGroup();asg.setRegion("us-east-1");asg.setAutoScalingGroupName("app-asg");@@ -409,6 +410,29 @@ class AutoScalingReconcilerTest {verify(ssmCommandService).failActiveInvocationsForInstances("us-east-1", Set.of("i-dead"), "Undeliverable");}+ @Test+ void reconcileDeregistersStaleInstanceFromClassicLoadBalancerBeforePruning() {+ AutoScalingService asgService = mock(AutoScalingService.class);+ Ec2Service ec2Service = mock(Ec2Service.class);+ ElbV2Service elbV2Service = mock(ElbV2Service.class);+ ElbClassicService elbClassicService = mock(ElbClassicService.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(+ asgService, ec2Service, elbV2Service, elbClassicService, null);+ AutoScalingGroup asg = new AutoScalingGroup();+ asg.setRegion("us-east-1");+ asg.setAutoScalingGroupName("app-asg");+ asg.setDesiredCapacity(0);+ asg.setLoadBalancerNames(List.of("classic-lb"));+ asg.getInstances().add(instance("i-dead", "InService"));+ when(ec2Service.isInstanceContainerRunning("i-dead")).thenReturn(false);++ reconciler.reconcile(asg);++ assertEquals(0, asg.getInstances().size());+ verify(elbClassicService).deregisterInstances(+ eq(asg.getRegion()), eq("classic-lb"), eq(List.of("i-dead")));+ }+@Testvoid reconcilePromotesPendingAsgInstanceWhenEc2InstanceIsRunning() {AutoScalingService asgService = mock(AutoScalingService.class);diff --git a/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicHealthCheckTargetTest.java b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicHealthCheckTargetTest.javanew file mode 100644index 0000000000..aac9d5f16a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicHealthCheckTargetTest.java@@ -0,0 +1,50 @@+package io.github.hectorvent.floci.services.elb;++import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;++/**+ * The Classic {@code HealthCheck.Target} grammar — one string carrying protocol, port and, for the+ * HTTP protocols, a path. ELBv2 splits these across three members, which is why this parsing+ * exists at all.+ */+class ElbClassicHealthCheckTargetTest {++ @Test+ void httpTargetCarriesItsPath() {+ ElbClassicHealthChecker.Target target = ElbClassicHealthChecker.Target.parse("HTTP:8080/health");+ assertEquals("http", target.scheme());+ assertEquals(8080, target.port());+ assertEquals("/health", target.path());+ }++ @Test+ void httpTargetWithNoPathDefaultsToRoot() {+ ElbClassicHealthChecker.Target target = ElbClassicHealthChecker.Target.parse("HTTP:80");+ assertEquals("/", target.path());+ }++ @Test+ void tcpTargetHasNoPathAndSoIsProbedByConnection() {+ ElbClassicHealthChecker.Target target = ElbClassicHealthChecker.Target.parse("TCP:8080");+ assertNull(target.path());+ assertNull(target.scheme());+ assertEquals(8080, target.port());+ }++ @Test+ void sslTargetIsAConnectionProbeToo() {+ assertNull(ElbClassicHealthChecker.Target.parse("SSL:443").path());+ }++ @Test+ void malformedTargetsAreRejectedRatherThanGuessed() {+ assertNull(ElbClassicHealthChecker.Target.parse(null));+ assertNull(ElbClassicHealthChecker.Target.parse(""));+ assertNull(ElbClassicHealthChecker.Target.parse("HTTP"));+ assertNull(ElbClassicHealthChecker.Target.parse("HTTP:notaport/"));+ assertNull(ElbClassicHealthChecker.Target.parse("GOPHER:70/"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicIntegrationTest.javanew file mode 100644index 0000000000..89719c6cd6--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicIntegrationTest.java@@ -0,0 +1,571 @@+package io.github.hectorvent.floci.services.elb;++import io.github.hectorvent.floci.services.ec2.Ec2Service;+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.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItems;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Classic (2012-06-01) Elastic Load Balancing over the Query protocol.+ *+ * <p>Classic ELB and ELBv2 share one endpoint host and one credential scope, so these tests also+ * pin the routing: a request declaring {@code Version=2012-06-01} must be answered by the Classic+ * implementation, in the 2012-06-01 namespace, and one declaring {@code Version=2015-12-01} must+ * still reach ELBv2.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class ElbClassicIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260427/us-east-1/elasticloadbalancing/aws4_request";+ private static final String V1 = "2012-06-01";+ private static final String V2 = "2015-12-01";+ private static final String CLASSIC_XMLNS =+ "http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/";+ private static final String V2_XMLNS =+ "https://elasticloadbalancing.amazonaws.com/doc/2015-12-01/";++ private static final String LB = "classic-elb-1";++ private static String subnetA() { return Ec2Service.defaultSubnetId("us-east-1", "a"); }++ @Test+ @Order(1)+ void createLoadBalancerAnswersTheClassicApiNotTheV2One() {+ String body = given()+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Scheme", "internet-facing")+ .formParam("Subnets.member.1", subnetA())+ .formParam("SecurityGroups.member.1", "sg-classic")+ .formParam("Listeners.member.1.Protocol", "HTTP")+ .formParam("Listeners.member.1.LoadBalancerPort", "80")+ .formParam("Listeners.member.1.InstanceProtocol", "HTTP")+ .formParam("Listeners.member.1.InstancePort", "8080")+ .formParam("Tags.member.1.Key", "gw:example")+ .formParam("Tags.member.1.Value", "with-elb")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .contentType("application/xml")+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.DNSName",+ containsString(LB + "-"))+ .extract().asString();++ // The two defects this fixes: wrong namespace, and an ELBv2 object in a Classic reply.+ assertTrue(body.contains("xmlns=\"" + CLASSIC_XMLNS + "\""),+ "Classic response must declare the 2012-06-01 namespace: " + body);+ assertFalse(body.contains(V2_XMLNS),+ "Classic response must not be in the 2015-12-01 namespace: " + body);+ assertFalse(body.contains("LoadBalancerArn"),+ "Classic load balancers have no ARN: " + body);+ assertFalse(body.contains("<LoadBalancers>"),+ "CreateLoadBalancerResult carries DNSName only, never a LoadBalancers list: " + body);+ }++ @Test+ @Order(2)+ void loadBalancerNameIsAcceptedRatherThanRejectedAsMissing() {+ // The reported symptom: 'Name is required for load balancer.' for a well-formed v1 request.+ given()+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", "classic-elb-name-ok")+ .formParam("Listeners.member.1.Protocol", "TCP")+ .formParam("Listeners.member.1.LoadBalancerPort", "443")+ .formParam("Listeners.member.1.InstancePort", "443")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.DNSName",+ containsString("classic-elb-name-ok-"));++ given()+ .formParam("Action", "DeleteLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", "classic-elb-name-ok")+ .header("Authorization", AUTH)+ .when().post("/").then().statusCode(200);+ }++ @Test+ @Order(3)+ void createRejectsARequestWithNoListeners() {+ given()+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", "classic-no-listeners")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ // Not "Name is required for load balancer." — that is the v2 handler's message,+ // and seeing it here means a v1 request reached the wrong API again.+ .body("ErrorResponse.Error.Message", containsString("listener"));+ }++ @Test+ @Order(4)+ void duplicateNameIsRejected() {+ given()+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Listeners.member.1.Protocol", "HTTP")+ .formParam("Listeners.member.1.LoadBalancerPort", "80")+ .formParam("Listeners.member.1.InstancePort", "8080")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("DuplicateLoadBalancerName"));+ }++ @Test+ @Order(5)+ void describeLoadBalancersReturnsTheClassicDescriptionShape() {+ String body = given()+ .formParam("Action", "DescribeLoadBalancers")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.LoadBalancerName", equalTo(LB))+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.Scheme", equalTo("internet-facing"))+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.Subnets.member", equalTo(subnetA()))+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.SecurityGroups.member",+ equalTo("sg-classic"))+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.ListenerDescriptions.member"+ + ".Listener.InstancePort", equalTo("8080"))+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.HealthCheck.Target", equalTo("TCP:80"))+ .extract().asString();+ assertTrue(body.contains("xmlns=\"" + CLASSIC_XMLNS + "\""), body);+ assertFalse(body.contains("LoadBalancerArn"), body);+ }++ @Test+ @Order(6)+ void describeUnknownLoadBalancerIsNotFound() {+ given()+ .formParam("Action", "DescribeLoadBalancers")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", "no-such-elb")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("LoadBalancerNotFound"));+ }++ @Test+ @Order(7)+ void configureHealthCheckStoresAndEchoesTheCheck() {+ given()+ .formParam("Action", "ConfigureHealthCheck")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("HealthCheck.Target", "HTTP:8080/")+ .formParam("HealthCheck.Interval", "10")+ .formParam("HealthCheck.Timeout", "3")+ .formParam("HealthCheck.HealthyThreshold", "2")+ .formParam("HealthCheck.UnhealthyThreshold", "2")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ConfigureHealthCheckResponse.ConfigureHealthCheckResult.HealthCheck.Target",+ equalTo("HTTP:8080/"))+ .body("ConfigureHealthCheckResponse.ConfigureHealthCheckResult.HealthCheck.Interval",+ equalTo("10"));+ }++ @Test+ @Order(8)+ void configureHealthCheckRejectsAnIntervalOutsideTheModelRange() {+ given()+ .formParam("Action", "ConfigureHealthCheck")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("HealthCheck.Target", "HTTP:8080/")+ .formParam("HealthCheck.Interval", "1")+ .formParam("HealthCheck.Timeout", "3")+ .formParam("HealthCheck.HealthyThreshold", "2")+ .formParam("HealthCheck.UnhealthyThreshold", "2")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ }++ @Test+ @Order(9)+ void registerDescribeAndDeregisterInstances() {+ given()+ .formParam("Action", "RegisterInstancesWithLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Instances.member.1.InstanceId", "i-1111111111111111a")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("RegisterInstancesWithLoadBalancerResponse"+ + ".RegisterInstancesWithLoadBalancerResult.Instances.member.InstanceId",+ equalTo("i-1111111111111111a"));++ given()+ .formParam("Action", "DescribeInstanceHealth")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeInstanceHealthResponse.DescribeInstanceHealthResult"+ + ".InstanceStates.member.InstanceId", equalTo("i-1111111111111111a"))+ .body("DescribeInstanceHealthResponse.DescribeInstanceHealthResult"+ + ".InstanceStates.member.State", equalTo("InService"));++ given()+ .formParam("Action", "DeregisterInstancesFromLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Instances.member.1.InstanceId", "i-1111111111111111a")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DeregisterInstancesFromLoadBalancerResponse"+ + ".DeregisterInstancesFromLoadBalancerResult.Instances", equalTo(""));+ }++ @Test+ @Order(10)+ void describeInstanceHealthRejectsAnUnregisteredInstance() {+ given()+ .formParam("Action", "DescribeInstanceHealth")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Instances.member.1.InstanceId", "i-not-registered")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidInstance"));+ }++ @Test+ @Order(11)+ void modifyAndDescribeAttributesRoundTrip() {+ given()+ .formParam("Action", "ModifyLoadBalancerAttributes")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("LoadBalancerAttributes.CrossZoneLoadBalancing.Enabled", "true")+ .formParam("LoadBalancerAttributes.ConnectionDraining.Enabled", "true")+ .formParam("LoadBalancerAttributes.ConnectionDraining.Timeout", "300")+ .formParam("LoadBalancerAttributes.ConnectionSettings.IdleTimeout", "90")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyLoadBalancerAttributesResponse.ModifyLoadBalancerAttributesResult"+ + ".LoadBalancerName", equalTo(LB));++ given()+ .formParam("Action", "DescribeLoadBalancerAttributes")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLoadBalancerAttributesResponse"+ + ".DescribeLoadBalancerAttributesResult.LoadBalancerAttributes"+ + ".CrossZoneLoadBalancing.Enabled", equalTo("true"))+ .body("DescribeLoadBalancerAttributesResponse"+ + ".DescribeLoadBalancerAttributesResult.LoadBalancerAttributes"+ + ".ConnectionDraining.Timeout", equalTo("300"))+ .body("DescribeLoadBalancerAttributesResponse"+ + ".DescribeLoadBalancerAttributesResult.LoadBalancerAttributes"+ + ".ConnectionSettings.IdleTimeout", equalTo("90"))+ // Untouched members keep their AWS defaults rather than disappearing.+ .body("DescribeLoadBalancerAttributesResponse"+ + ".DescribeLoadBalancerAttributesResult.LoadBalancerAttributes"+ + ".AccessLog.Enabled", equalTo("false"));+ }++ @Test+ @Order(12)+ void listenersCanBeAddedAndRemoved() {+ given()+ .formParam("Action", "CreateLoadBalancerListeners")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Listeners.member.1.Protocol", "TCP")+ .formParam("Listeners.member.1.LoadBalancerPort", "8443")+ .formParam("Listeners.member.1.InstancePort", "8443")+ .header("Authorization", AUTH)+ .when().post("/").then().statusCode(200);++ given()+ .formParam("Action", "DescribeLoadBalancers")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.ListenerDescriptions.member"+ + ".Listener.LoadBalancerPort", hasItems("80", "8443"));++ given()+ .formParam("Action", "DeleteLoadBalancerListeners")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("LoadBalancerPorts.member.1", "8443")+ .header("Authorization", AUTH)+ .when().post("/").then().statusCode(200);++ given()+ .formParam("Action", "DescribeLoadBalancers")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.ListenerDescriptions.member"+ + ".Listener.LoadBalancerPort", equalTo("80"));+ }++ @Test+ @Order(13)+ void tagsRoundTripByLoadBalancerName() {+ given()+ .formParam("Action", "DescribeTags")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeTagsResponse.DescribeTagsResult.TagDescriptions.member"+ + ".LoadBalancerName", equalTo(LB))+ .body("DescribeTagsResponse.DescribeTagsResult.TagDescriptions.member"+ + ".Tags.member.Key", equalTo("gw:example"));++ given()+ .formParam("Action", "AddTags")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .formParam("Tags.member.1.Key", "owner")+ .formParam("Tags.member.1.Value", "harness")+ .header("Authorization", AUTH)+ .when().post("/").then().statusCode(200);++ given()+ .formParam("Action", "RemoveTags")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .formParam("Tags.member.1.Key", "gw:example")+ .header("Authorization", AUTH)+ .when().post("/").then().statusCode(200);++ given()+ .formParam("Action", "DescribeTags")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeTagsResponse.DescribeTagsResult.TagDescriptions.member"+ + ".Tags.member.Key", equalTo("owner"));+ }++ @Test+ @Order(14)+ void subnetAndSecurityGroupChangesRoundTrip() {+ given()+ .formParam("Action", "AttachLoadBalancerToSubnets")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Subnets.member.1", Ec2Service.defaultSubnetId("us-east-1", "b"))+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("AttachLoadBalancerToSubnetsResponse.AttachLoadBalancerToSubnetsResult"+ + ".Subnets.member", hasItems(subnetA(),+ Ec2Service.defaultSubnetId("us-east-1", "b")));++ given()+ .formParam("Action", "DetachLoadBalancerFromSubnets")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("Subnets.member.1", Ec2Service.defaultSubnetId("us-east-1", "b"))+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DetachLoadBalancerFromSubnetsResponse.DetachLoadBalancerFromSubnetsResult"+ + ".Subnets.member", equalTo(subnetA()));++ given()+ .formParam("Action", "ApplySecurityGroupsToLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("SecurityGroups.member.1", "sg-replaced")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ApplySecurityGroupsToLoadBalancerResponse"+ + ".ApplySecurityGroupsToLoadBalancerResult.SecurityGroups.member",+ equalTo("sg-replaced"));+ }++ @Test+ @Order(15)+ void unimplementedClassicPolicyOperationsSaySoInTheClassicNamespace() {+ String body = given()+ .formParam("Action", "CreateLBCookieStickinessPolicy")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .formParam("PolicyName", "stickiness")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("UnsupportedOperation"))+ .extract().asString();+ assertTrue(body.contains(CLASSIC_XMLNS), body);+ }++ @Test+ @Order(16)+ void aRequestWithoutAVersionRoutesOnItsParameterShape() {+ // A hand-rolled client that omitted Version but named a load balancer is Classic.+ given()+ .formParam("Action", "DescribeLoadBalancers")+ .formParam("LoadBalancerNames.member.1", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult"+ + ".LoadBalancerDescriptions.member.LoadBalancerName", equalTo(LB));+ }++ @Test+ @Order(17)+ void elbV2RequestsStillReachTheV2Handler() {+ String body = given()+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Version", V2)+ .formParam("Name", "v2-still-works")+ .formParam("Type", "application")+ .formParam("Subnets.member.1", Ec2Service.defaultSubnetId("us-east-1", "a"))+ .formParam("Subnets.member.2", Ec2Service.defaultSubnetId("us-east-1", "b"))+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member"+ + ".LoadBalancerName", equalTo("v2-still-works"))+ .extract().asString();+ assertTrue(body.contains(V2_XMLNS), body);++ given()+ .formParam("Action", "DescribeLoadBalancers")+ .formParam("Version", V2)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult.LoadBalancers"+ + ".member.LoadBalancerName", not(hasItems(LB)));+ }++ @Test+ @Order(18)+ void deleteRemovesTheClassicLoadBalancerAndIsIdempotent() {+ given()+ .formParam("Action", "DeleteLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .header("Authorization", AUTH)+ .when().post("/").then().statusCode(200);++ // AWS answers a delete of something already gone with success.+ given()+ .formParam("Action", "DeleteLoadBalancer")+ .formParam("Version", V1)+ .formParam("LoadBalancerName", LB)+ .header("Authorization", AUTH)+ .when().post("/").then().statusCode(200);++ given()+ .formParam("Action", "DescribeLoadBalancers")+ .formParam("Version", V1)+ .formParam("LoadBalancerNames.member.1", LB)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("LoadBalancerNotFound"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicServiceTest.javanew file mode 100644index 0000000000..0213abea6c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elb/ElbClassicServiceTest.java@@ -0,0 +1,243 @@+package io.github.hectorvent.floci.services.elb;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Subnet;+import io.github.hectorvent.floci.services.elb.model.ClassicHealthCheck;+import io.github.hectorvent.floci.services.elb.model.ClassicListener;+import io.github.hectorvent.floci.services.elb.model.ClassicLoadBalancer;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.ExtendWith;+import org.mockito.Mock;+import org.mockito.junit.jupiter.MockitoExtension;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyList;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Mockito.lenient;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++@ExtendWith(MockitoExtension.class)+class ElbClassicServiceTest {++ private static final String REGION = "us-west-2";++ @Mock+ Ec2Service ec2Service;++ @Mock+ ElbClassicHealthChecker healthChecker;++ private ElbClassicService service;++ @BeforeEach+ void setUp() {+ service = new ElbClassicService(ec2Service, healthChecker, null, null);+ lenient().when(ec2Service.describeSubnets(anyString(), anyList(), any()))+ .thenAnswer(invocation -> {+ List<String> ids = invocation.getArgument(1);+ return ids.stream().map(id -> {+ Subnet subnet = new Subnet();+ subnet.setSubnetId(id);+ subnet.setVpcId("vpc-1");+ subnet.setAvailabilityZone(REGION + id.substring(id.length() - 1));+ return subnet;+ }).toList();+ });+ }++ private static ClassicListener httpListener() {+ ClassicListener listener = new ClassicListener();+ listener.setProtocol("HTTP");+ listener.setLoadBalancerPort(80);+ listener.setInstanceProtocol("HTTP");+ listener.setInstancePort(8080);+ return listener;+ }++ private ClassicLoadBalancer create(String name) {+ return service.createLoadBalancer(REGION, name, List.of(httpListener()),+ List.of(), List.of("subnet-a"), List.of("sg-1"), null, Map.of());+ }++ @Test+ void createGivesADnsNameAndTheAwsDefaultHealthCheck() {+ ClassicLoadBalancer lb = create("my-elb");++ assertTrue(lb.getDnsName().startsWith("my-elb-"));+ assertEquals("internet-facing", lb.getScheme());+ assertEquals("vpc-1", lb.getVpcId());+ assertEquals(List.of(REGION + "a"), lb.getAvailabilityZones());+ // AWS's documented defaults for a load balancer that has never been configured.+ assertEquals("TCP:80", lb.getHealthCheck().getTarget());+ assertEquals(30, lb.getHealthCheck().getInterval());+ assertEquals(10, lb.getHealthCheck().getHealthyThreshold());+ verify(healthChecker).startMonitoring(lb);+ }++ @Test+ void createRejectsAMissingNameWithTheClassicParameterName() {+ AwsException e = assertThrows(AwsException.class, () ->+ service.createLoadBalancer(REGION, null, List.of(httpListener()),+ List.of(), List.of(), List.of(), null, Map.of()));+ assertEquals("ValidationError", e.getErrorCode());+ assertTrue(e.getMessage().contains("LoadBalancerName"), e.getMessage());+ }++ @Test+ void createRejectsAListenerMissingARequiredMember() {+ ClassicListener incomplete = new ClassicListener();+ incomplete.setProtocol("HTTP");+ incomplete.setLoadBalancerPort(80);+ AwsException e = assertThrows(AwsException.class, () ->+ service.createLoadBalancer(REGION, "my-elb", List.of(incomplete),+ List.of(), List.of(), List.of(), null, Map.of()));+ assertEquals("ValidationError", e.getErrorCode());+ }++ @Test+ void createRejectsAnEmptyListenerListNamingTheMissingMember() {+ AwsException e = assertThrows(AwsException.class, () ->+ service.createLoadBalancer(REGION, "my-elb", List.of(),+ List.of(), List.of("subnet-a"), List.of("sg-1"), null, Map.of()));+ assertEquals("ValidationError", e.getErrorCode());+ assertTrue(e.getMessage().contains("listener"), e.getMessage());+ }++ /**+ * CreateLoadBalancer's Errors table documents InvalidConfigurationRequest at HTTP 409, not+ * 400 — a client that retries on 409 but fails hard on 400 depends on the difference.+ */+ @Test+ void subnetsSpanningTwoVpcsAreRejectedWithTheDocumentedStatus() {+ when(ec2Service.describeSubnets(anyString(), anyList(), any()))+ .thenAnswer(invocation -> {+ List<String> ids = invocation.getArgument(1);+ return ids.stream().map(id -> {+ Subnet subnet = new Subnet();+ subnet.setSubnetId(id);+ subnet.setVpcId("vpc-" + id.charAt(id.length() - 1));+ subnet.setAvailabilityZone(REGION + id.charAt(id.length() - 1));+ return subnet;+ }).toList();+ });++ AwsException e = assertThrows(AwsException.class, () ->+ service.createLoadBalancer(REGION, "my-elb", List.of(httpListener()),+ List.of(), List.of("subnet-a", "subnet-b"), List.of("sg-1"), null, Map.of()));+ assertEquals("InvalidConfigurationRequest", e.getErrorCode());+ assertEquals(409, e.getHttpStatus());+ }++ @Test+ void createRejectsADuplicateName() {+ create("my-elb");+ AwsException e = assertThrows(AwsException.class, () -> create("my-elb"));+ assertEquals("DuplicateLoadBalancerName", e.getErrorCode());+ }++ @Test+ void loadBalancersAreScopedByRegion() {+ create("my-elb");+ assertTrue(service.hasLoadBalancer(REGION, "my-elb"));+ assertTrue(service.describeLoadBalancers("eu-west-1", null).isEmpty());+ }++ @Test+ void configureHealthCheckStoresAndRearmsTheChecker() {+ ClassicLoadBalancer lb = create("my-elb");+ ClassicHealthCheck hc = new ClassicHealthCheck();+ hc.setTarget("HTTP:8080/health");+ hc.setInterval(10);+ hc.setTimeout(3);+ hc.setHealthyThreshold(2);+ hc.setUnhealthyThreshold(2);++ service.configureHealthCheck(REGION, "my-elb", hc);++ assertEquals("HTTP:8080/health", lb.getHealthCheck().getTarget());+ verify(healthChecker).healthCheckChanged(lb);+ }++ @Test+ void configureHealthCheckEnforcesTheRangesTheModelDeclares() {+ create("my-elb");+ ClassicHealthCheck hc = new ClassicHealthCheck();+ hc.setTarget("HTTP:8080/");+ hc.setInterval(301);+ hc.setTimeout(3);+ hc.setHealthyThreshold(2);+ hc.setUnhealthyThreshold(2);++ AwsException e = assertThrows(AwsException.class,+ () -> service.configureHealthCheck(REGION, "my-elb", hc));+ assertEquals("ValidationError", e.getErrorCode());+ }++ @Test+ void registerAndDeregisterInstancesAreIdempotent() {+ create("my-elb");+ service.registerInstances(REGION, "my-elb", List.of("i-1"));+ assertEquals(List.of("i-1"), service.registerInstances(REGION, "my-elb", List.of("i-1")));+ assertEquals(List.of(), service.deregisterInstances(REGION, "my-elb", List.of("i-1")));+ verify(healthChecker).deregisterInstances(REGION, "my-elb", List.of("i-1"));+ }++ @Test+ void describeInstanceHealthRejectsAnInstanceThatIsNotRegistered() {+ create("my-elb");+ AwsException e = assertThrows(AwsException.class,+ () -> service.describeInstanceHealth(REGION, "my-elb", List.of("i-unknown")));+ assertEquals("InvalidInstance", e.getErrorCode());+ }++ @Test+ void modifyAttributesLeavesUnsentMembersAtTheirDefaults() {+ create("my-elb");+ service.modifyLoadBalancerAttributes(REGION, "my-elb",+ new ElbClassicService.AttributeUpdate(true, null, null, null, null,+ true, 300, null, Map.of()));++ ClassicLoadBalancer lb = service.requireLoadBalancer(REGION, "my-elb");+ assertTrue(lb.getAttributes().isCrossZoneLoadBalancingEnabled());+ assertTrue(lb.getAttributes().isConnectionDrainingEnabled());+ assertEquals(300, lb.getAttributes().getConnectionDrainingTimeout());+ assertEquals(60, lb.getAttributes().getIdleTimeout());+ assertNull(lb.getAttributes().getAccessLogS3BucketName());+ }++ @Test+ void deleteIsSilentForALoadBalancerThatDoesNotExist() {+ service.deleteLoadBalancer(REGION, "never-existed");+ assertThrows(AwsException.class, () -> service.requireLoadBalancer(REGION, "never-existed"));+ }++ @Test+ void addingAConflictingListenerOnAPortInUseIsRejected() {+ create("my-elb");+ ClassicListener conflicting = new ClassicListener();+ conflicting.setProtocol("TCP");+ conflicting.setLoadBalancerPort(80);+ conflicting.setInstancePort(9999);++ AwsException e = assertThrows(AwsException.class, () ->+ service.createLoadBalancerListeners(REGION, "my-elb", List.of(conflicting)));+ assertEquals("DuplicateListener", e.getErrorCode());+ }++ @Test+ void repeatingAnIdenticalListenerIsAccepted() {+ ClassicLoadBalancer lb = create("my-elb");+ service.createLoadBalancerListeners(REGION, "my-elb", List.of(httpListener()));+ assertEquals(1, lb.getListeners().size());+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex 0954f2fcaf..277d7dd85d 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -273,6 +273,9 @@ floci:mock: truepipes:enabled: true+ elb:+ enabled: true+ mock: trueelbv2:enabled: truemock: truediff --git a/tools/docs/services.yaml b/tools/docs/services.yamlindex 1aa55e67a8..f9669b7533 100644--- a/tools/docs/services.yaml+++ b/tools/docs/services.yaml@@ -221,6 +221,7 @@ deferred_handlers:- { path: src/main/java/io/github/hectorvent/floci/services/ecr/EcrJsonHandler.java } # doc packs multiple actions per row (`A` / `B`) + REST endpoints; needs de-grouping- { path: src/main/java/io/github/hectorvent/floci/services/ecs/EcsJsonHandler.java } # non-tabular doc (grouped/inline)- { path: src/main/java/io/github/hectorvent/floci/services/elasticbeanstalk/ElasticBeanstalkQueryHandler.java } # non-tabular doc (grouped/inline)+ - { path: src/main/java/io/github/hectorvent/floci/services/elb/ElbClassicQueryHandler.java } # non-tabular doc (grouped/inline)- { path: src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2QueryHandler.java } # non-tabular doc (grouped/inline)- { path: src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java } # non-tabular doc (grouped/inline)- { path: src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java } # non-tabular doc (grouped/inline)