Skip to content

armgit / floci

Public Imported from GitHub
0

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

Improve ELBv2 target resolution and persistence (#1254)

Jason van Zyld8d70bfd48e2
diff --git a/docs/services/elb.md b/docs/services/elb.md
index 63f77b1473..0f6d0d12a1 100644
--- a/docs/services/elb.md
+++ b/docs/services/elb.md
@@ -2,12 +2,12 @@
**Protocol:** Query (XML) — `POST http://localhost:4566/` with `Action=` parameter
-Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB) through the ELBv2 management API. This is a Phase 1 implementation: the full CRUD control plane is available and AWS SDK / CLI / Terraform compatible. Data-plane traffic forwarding (actual TCP listener ports) is planned for Phase 2.
+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.
## Supported Actions
### Load Balancers
-`CreateLoadBalancer` · `DescribeLoadBalancers` · `DeleteLoadBalancer` · `ModifyLoadBalancerAttributes` · `DescribeLoadBalancerAttributes` · `SetSecurityGroups` · `SetSubnets` · `SetIpAddressType`
+`CreateLoadBalancer` · `DescribeLoadBalancers` · `DeleteLoadBalancer` · `ModifyLoadBalancerAttributes` · `DescribeLoadBalancerAttributes` · `DescribeCapacityReservation` · `SetSecurityGroups` · `SetSubnets` · `SetIpAddressType`
### Target Groups
`CreateTargetGroup` · `DescribeTargetGroups` · `ModifyTargetGroup` · `DeleteTargetGroup` · `ModifyTargetGroupAttributes` · `DescribeTargetGroupAttributes`
@@ -16,7 +16,7 @@ Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB)
`RegisterTargets` · `DeregisterTargets` · `DescribeTargetHealth`
### Listeners
-`CreateListener` · `DescribeListeners` · `ModifyListener` · `DeleteListener` · `AddListenerCertificates` · `RemoveListenerCertificates` · `DescribeListenerCertificates`
+`CreateListener` · `DescribeListeners` · `ModifyListener` · `ModifyListenerAttributes` · `DescribeListenerAttributes` · `DeleteListener` · `AddListenerCertificates` · `RemoveListenerCertificates` · `DescribeListenerCertificates`
### Rules
`CreateRule` · `DescribeRules` · `ModifyRule` · `DeleteRule` · `SetRulePriorities`
@@ -29,8 +29,11 @@ Floci supports Application Load Balancers (ALB) and Network Load Balancers (NLB)
## Behavior Notes
-- Load balancers are created in `provisioning` state and transition to `active` immediately on subsequent describes.
-- Target health always returns `initial` state with reason `Elb.RegistrationInProgress` — data-plane health checks are not performed in Phase 1.
+- Load balancer, target group, listener, rule, and tag state is persisted through Floci storage and rebuilt on service startup.
+- Load balancers are created in `active` state.
+- HTTP listener sockets are preserved when listener actions change and are restarted only when socket-level settings such as port change.
+- Instance targets are resolved through EC2 instance private addresses so local load balancer traffic can reach containers.
+- Target health starts in `initial` state with reason `Elb.RegistrationInProgress` and is updated by Floci's health checker when monitoring is active.
- Each `CreateListener` automatically creates an immutable default rule (`priority=default`, `isDefault=true`). This rule cannot be deleted; use `ModifyListener` to change its action.
- Rule priorities are validated for uniqueness. `SetRulePriorities` is atomic: all priority assignments are validated before any change is committed.
- `DeleteTargetGroup` is rejected with `ResourceInUse` while the target group is referenced by any listener or rule.
@@ -111,6 +114,6 @@ aws elbv2 delete-target-group \
|---|---|---|
| `FLOCI_SERVICES_ELBV2_ENABLED` | `true` | Enable or disable the ELBv2 service |
-## Phase 2 (Planned)
+## Listener Ports
-Phase 2 will bind real TCP listener ports on the host so traffic sent to a listener port is forwarded to registered targets. This requires exposing a port range (e.g., `8300-8399`) in the Docker Compose configuration, similar to how ElastiCache and RDS proxy ports work today.
+Listener sockets bind on the Floci host. Expose any listener ports you need in Docker Compose when Floci itself runs in a container, similar to RDS and ElastiCache proxy ports.
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java
index d0dbf31ba2..222dc69138 100644
--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java
@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.elbv2;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
import io.github.hectorvent.floci.services.elbv2.model.Action;
import io.github.hectorvent.floci.services.elbv2.model.Listener;
import io.github.hectorvent.floci.services.elbv2.model.Rule;
@@ -61,6 +62,9 @@ public class ElbV2DataPlane {
@Inject
LambdaService lambdaService;
+ @Inject
+ Ec2Service ec2Service;
+
@Inject
ObjectMapper objectMapper;
@@ -105,10 +109,27 @@ public class ElbV2DataPlane {
server.requestHandler(req -> handleRequest(req, listenerArn, region));
server.listen()
- .onSuccess(s -> LOG.infov("ELBv2 listener started on port {0} for {1}", String.valueOf(listener.getPort()), listenerArn))
- .onFailure(err -> LOG.warnv("ELBv2 listener failed to start on port {0}: {1}", String.valueOf(listener.getPort()), err.getMessage()));
+ .onSuccess(s -> {
+ servers.put(listenerArn, s);
+ LOG.infov("ELBv2 listener started on port {0} for {1}", String.valueOf(listener.getPort()), listenerArn);
+ })
+ .onFailure(err -> {
+ ruleChains.remove(listenerArn);
+ listenerRegions.remove(listenerArn);
+ LOG.warnv("ELBv2 listener failed to start on port {0}: {1}", String.valueOf(listener.getPort()), err.getMessage());
+ });
+ }
- servers.put(listenerArn, server);
+ public void restartListener(Listener listener, String region, List<Rule> rules) {
+ if (config.services().elbv2().mock()) {
+ return;
+ }
+ HttpServer server = servers.remove(listener.getListenerArn());
+ if (server == null) {
+ startListener(listener, region, rules);
+ return;
+ }
+ server.close().onComplete(ignored -> startListener(listener, region, rules));
}
public void stopListener(String listenerArn) {
@@ -192,7 +213,7 @@ public class ElbV2DataPlane {
int idx = Math.abs(counter.getAndIncrement() % candidates.size());
TargetDescription target = candidates.get(idx);
int targetPort = ElbV2HealthChecker.effectivePort(target, tg);
- proxyRequest(req, target.getId(), targetPort);
+ proxyRequest(req, ElbV2TargetResolver.resolveHost(ec2Service, tg, target), targetPort);
}
private void invokeLambdaTarget(io.vertx.core.http.HttpServerRequest req, String functionArn, String region) {
@@ -580,4 +601,4 @@ public class ElbV2DataPlane {
return params;
}
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.java
index 4f582ef47d..9215c86ec1 100644
--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.java
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.java
@@ -1,6 +1,7 @@
package io.github.hectorvent.floci.services.elbv2;
import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;
import io.github.hectorvent.floci.services.elbv2.model.TargetGroup;
import io.vertx.core.Vertx;
@@ -23,6 +24,7 @@ public class ElbV2HealthChecker {
private final Vertx vertx;
private final EmulatorConfig config;
+ private final Ec2Service ec2Service;
// tgArn → (targetKey → TargetState)
private final Map<String, Map<String, TargetState>> states = new ConcurrentHashMap<>();
@@ -30,9 +32,10 @@ public class ElbV2HealthChecker {
private final Map<String, Long> timers = new ConcurrentHashMap<>();
@Inject
- public ElbV2HealthChecker(Vertx vertx, EmulatorConfig config) {
+ public ElbV2HealthChecker(Vertx vertx, EmulatorConfig config, Ec2Service ec2Service) {
this.vertx = vertx;
this.config = config;
+ this.ec2Service = ec2Service;
}
public static int effectivePort(TargetDescription target, TargetGroup tg) {
@@ -120,13 +123,14 @@ public class ElbV2HealthChecker {
if (parts.length != 2) {
continue;
}
- String host = parts[0];
+ String targetId = parts[0];
int port;
try {
port = Integer.parseInt(parts[1]);
} catch (NumberFormatException e) {
continue;
}
+ String host = ElbV2TargetResolver.resolveHost(ec2Service, tg, targetId);
String path = tg.getHealthCheckPath() != null ? tg.getHealthCheckPath() : "/";
String matcher = tg.getMatcher() != null ? tg.getMatcher() : "200";
int timeout = tg.getHealthCheckTimeoutSeconds() != null ? tg.getHealthCheckTimeoutSeconds() : 5;
@@ -202,4 +206,4 @@ public class ElbV2HealthChecker {
volatile int consecutiveSuccesses = 0;
volatile int consecutiveFailures = 0;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java
index a786f0985f..0e975c0397 100644
--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java
@@ -1,11 +1,15 @@
package io.github.hectorvent.floci.services.elbv2;
+import com.fasterxml.jackson.core.type.TypeReference;
import io.github.hectorvent.floci.core.common.AwsArnUtils;
import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.common.RegionResolver;
+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.elbv2.model.*;
+import jakarta.annotation.PostConstruct;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
@@ -29,13 +33,16 @@ public class ElbV2Service {
@Inject
Ec2Service ec2Service;
+ @Inject
+ StorageFactory storageFactory;
+
private static final String CANONICAL_HOSTED_ZONE_ID = "Z35SXDOTRQ7X7K";
// region → ARN → resource
- private final Map<String, Map<String, LoadBalancer>> loadBalancers = new ConcurrentHashMap<>();
- private final Map<String, Map<String, TargetGroup>> targetGroups = new ConcurrentHashMap<>();
- private final Map<String, Map<String, Listener>> listeners = new ConcurrentHashMap<>();
- private final Map<String, Map<String, Rule>> rules = new ConcurrentHashMap<>();
+ private Map<String, Map<String, LoadBalancer>> loadBalancers = new ConcurrentHashMap<>();
+ private Map<String, Map<String, TargetGroup>> targetGroups = new ConcurrentHashMap<>();
+ private Map<String, Map<String, Listener>> listeners = new ConcurrentHashMap<>();
+ private Map<String, Map<String, Rule>> rules = new ConcurrentHashMap<>();
// indexes
private final Map<String, List<String>> lbToListeners = new ConcurrentHashMap<>(); // LB-ARN → listener ARNs
@@ -43,7 +50,91 @@ public class ElbV2Service {
private final Map<String, Set<String>> tgToLbs = new ConcurrentHashMap<>(); // TG-ARN → LB-ARNs
// tags: resource-ARN → {key → value}
- private final Map<String, Map<String, String>> tags = new ConcurrentHashMap<>();
+ private Map<String, Map<String, String>> tags = new ConcurrentHashMap<>();
+
+ @PostConstruct
+ void initializeStorage()
+ {
+ if (storageFactory == null) {
+ return;
+ }
+ this.loadBalancers = storageBacked("elbv2-load-balancers.json",
+ new TypeReference<Map<String, Map<String, LoadBalancer>>>() {});
+ this.targetGroups = storageBacked("elbv2-target-groups.json",
+ new TypeReference<Map<String, Map<String, TargetGroup>>>() {});
+ this.listeners = storageBacked("elbv2-listeners.json",
+ new TypeReference<Map<String, Map<String, Listener>>>() {});
+ this.rules = storageBacked("elbv2-rules.json",
+ new TypeReference<Map<String, Map<String, Rule>>>() {});
+ this.tags = storageBacked("elbv2-tags.json",
+ new TypeReference<Map<String, Map<String, String>>>() {});
+ normalizeRegionMaps(loadBalancers);
+ normalizeRegionMaps(targetGroups);
+ normalizeRegionMaps(listeners);
+ normalizeRegionMaps(rules);
+ normalizeRegionMaps(tags);
+ rebuildIndexes();
+ }
+
+ private <V> Map<String, V> storageBacked(String fileName, TypeReference<Map<String, V>> typeReference)
+ {
+ return new StorageBackedMap<>(storageFactory.create("elbv2", fileName, typeReference));
+ }
+
+ private <V> void normalizeRegionMaps(Map<String, Map<String, V>> resources) {
+ for (Map.Entry<String, Map<String, V>> entry : new ArrayList<>(resources.entrySet())) {
+ if (!(entry.getValue() instanceof ConcurrentHashMap)) {
+ resources.put(entry.getKey(), new ConcurrentHashMap<>(entry.getValue()));
+ }
+ }
+ }
+
+ private <V> void persistRegion(Map<String, Map<String, V>> resources, String region) {
+ Map<String, V> regionResources = resources.get(region);
+ if (regionResources != null) {
+ resources.put(region, regionResources);
+ }
+ }
+
+ private void rebuildIndexes()
+ {
+ lbToListeners.clear();
+ listenerToRules.clear();
+ tgToLbs.clear();
+
+ for (Map<String, Listener> regionListeners : listeners.values()) {
+ for (Listener listener : regionListeners.values()) {
+ lbToListeners.computeIfAbsent(listener.getLoadBalancerArn(), k -> new ArrayList<>())
+ .add(listener.getListenerArn());
+ }
+ }
+ for (Map<String, Rule> regionRules : rules.values()) {
+ for (Rule rule : regionRules.values()) {
+ listenerToRules.computeIfAbsent(rule.getListenerArn(), k -> new ArrayList<>())
+ .add(rule.getRuleArn());
+ }
+ }
+ for (Map.Entry<String, Map<String, TargetGroup>> regionEntry : targetGroups.entrySet()) {
+ for (TargetGroup targetGroup : regionEntry.getValue().values()) {
+ tgToLbs.computeIfAbsent(targetGroup.getTargetGroupArn(), k -> ConcurrentHashMap.newKeySet())
+ .addAll(targetGroup.getLoadBalancerArns());
+ if (healthChecker != null) {
+ healthChecker.startMonitoring(targetGroup);
+ if (!targetGroup.getTargets().isEmpty()) {
+ healthChecker.addTargets(targetGroup.getTargetGroupArn(), targetGroup.getTargets(), targetGroup);
+ }
+ }
+ }
+ }
+ for (Map.Entry<String, Map<String, Listener>> regionEntry : listeners.entrySet()) {
+ String region = regionEntry.getKey();
+ for (Listener listener : regionEntry.getValue().values()) {
+ if (dataPlane != null) {
+ dataPlane.startListener(listener, region, getListenerRules(region, listener.getListenerArn()));
+ }
+ }
+ }
+ }
// ── Load Balancers ────────────────────────────────────────────────────────
@@ -85,6 +176,7 @@ public class ElbV2Service {
if (securityGroups != null) lb.setSecurityGroups(new ArrayList<>(securityGroups));
regionLbs.put(arn, lb);
+ loadBalancers.put(region, regionLbs);
lbToListeners.put(arn, new ArrayList<>());
if (!initialTags.isEmpty()) {
tags.put(arn, new LinkedHashMap<>(initialTags));
@@ -135,10 +227,13 @@ public class ElbV2Service {
ruleArns.forEach(regionRules::remove);
}
}
+ listeners.put(region, regionListeners);
+ rules.put(region, regionRules);
}
// remove from TG index
tgToLbs.values().forEach(lbSet -> lbSet.remove(arn));
tags.remove(arn);
+ loadBalancers.put(region, regionLbs);
}
public Map<String, String> describeLoadBalancerAttributes(String region, String arn) {
@@ -149,6 +244,7 @@ public class ElbV2Service {
public void modifyLoadBalancerAttributes(String region, String arn, Map<String, String> newAttrs) {
LoadBalancer lb = requireLoadBalancer(region, arn);
lb.getAttributes().putAll(newAttrs);
+ persistRegion(loadBalancers, region);
}
/** Capacity reservation status for a load balancer. All fields are {@code null} when no
@@ -166,6 +262,7 @@ public class ElbV2Service {
public void setSecurityGroups(String region, String arn, List<String> sgIds) {
LoadBalancer lb = requireLoadBalancer(region, arn);
lb.setSecurityGroups(new ArrayList<>(sgIds));
+ persistRegion(loadBalancers, region);
}
public void setSubnets(String region, String arn, List<String> subnets) {
@@ -179,11 +276,13 @@ public class ElbV2Service {
if (vpcId != null) {
lb.setVpcId(vpcId);
}
+ persistRegion(loadBalancers, region);
}
public void setIpAddressType(String region, String arn, String ipAddressType) {
LoadBalancer lb = requireLoadBalancer(region, arn);
lb.setIpAddressType(ipAddressType);
+ persistRegion(loadBalancers, region);
}
// ── Target Groups ─────────────────────────────────────────────────────────
@@ -231,6 +330,7 @@ public class ElbV2Service {
tg.setMatcher(matcher != null ? matcher : "200");
regionTgs.put(arn, tg);
+ targetGroups.put(region, regionTgs);
tgToLbs.put(arn, ConcurrentHashMap.newKeySet());
if (!initialTags.isEmpty()) {
tags.put(arn, new LinkedHashMap<>(initialTags));
@@ -278,6 +378,7 @@ public class ElbV2Service {
}
healthChecker.stopMonitoring(arn);
targetGroups.getOrDefault(region, Map.of()).remove(arn);
+ persistRegion(targetGroups, region);
tgToLbs.remove(arn);
tags.remove(arn);
}
@@ -297,6 +398,7 @@ public class ElbV2Service {
if (healthyThreshold != null) tg.setHealthyThresholdCount(healthyThreshold);
if (unhealthyThreshold != null) tg.setUnhealthyThresholdCount(unhealthyThreshold);
if (matcher != null) tg.setMatcher(matcher);
+ persistRegion(targetGroups, region);
}
public Map<String, String> describeTargetGroupAttributes(String region, String arn) {
@@ -307,6 +409,7 @@ public class ElbV2Service {
public void modifyTargetGroupAttributes(String region, String arn, Map<String, String> newAttrs) {
TargetGroup tg = requireTargetGroup(region, arn);
tg.getAttributes().putAll(newAttrs);
+ persistRegion(targetGroups, region);
}
// ── Listeners ─────────────────────────────────────────────────────────────
@@ -346,12 +449,18 @@ public class ElbV2Service {
listener.setAlpnPolicy(alpnPolicy != null ? new ArrayList<>(alpnPolicy) : new ArrayList<>());
regionListeners.put(listenerArn, listener);
+ listeners.put(region, regionListeners);
lbToListeners.computeIfAbsent(lbArn, k -> new ArrayList<>()).add(listenerArn);
// auto-create the default rule
Rule defaultRule = buildDefaultRule(region, listenerArn, lb, lbId, listenerId, defaultActions);
- rules.computeIfAbsent(region, k -> new ConcurrentHashMap<>()).put(defaultRule.getRuleArn(), defaultRule);
+ Map<String, Rule> regionRules = rules.computeIfAbsent(region, k -> new ConcurrentHashMap<>());
+ regionRules.put(defaultRule.getRuleArn(), defaultRule);
+ rules.put(region, regionRules);
listenerToRules.computeIfAbsent(listenerArn, k -> new ArrayList<>()).add(defaultRule.getRuleArn());
+ for (Action action : defaultRule.getActions()) {
+ linkTgToLb(action, lbArn);
+ }
if (!initialTags.isEmpty()) {
tags.put(listenerArn, new LinkedHashMap<>(initialTags));
@@ -384,6 +493,7 @@ public class ElbV2Service {
public void modifyListenerAttributes(String region, String arn, Map<String, String> newAttrs) {
Listener listener = requireListener(region, arn);
listener.getAttributes().putAll(newAttrs);
+ persistRegion(listeners, region);
}
public void deleteListener(String region, String listenerArn) {
@@ -400,6 +510,8 @@ public class ElbV2Service {
if (ruleArns != null) {
ruleArns.forEach(regionRules::remove);
}
+ listeners.put(region, regionListeners);
+ rules.put(region, regionRules);
tags.remove(listenerArn);
unlinkUnreferencedTargetGroups(region, listener.getLoadBalancerArn());
}
@@ -408,6 +520,8 @@ public class ElbV2Service {
String sslPolicy, List<String> certificates,
List<Action> defaultActions, List<String> alpnPolicy) {
Listener listener = requireListener(region, listenerArn);
+ boolean restartDataPlane = false;
+ boolean recompileRules = false;
if (port != null && !Objects.equals(listener.getPort(), port)) {
// check duplicate port on same LB
@@ -420,6 +534,7 @@ public class ElbV2Service {
"A listener already exists on port " + port + " for this load balancer.", 400);
}
listener.setPort(port);
+ restartDataPlane = true;
}
if (protocol != null) listener.setProtocol(protocol);
if (sslPolicy != null) listener.setSslPolicy(sslPolicy);
@@ -430,11 +545,21 @@ public class ElbV2Service {
// update the default rule's actions
listenerToRules.getOrDefault(listenerArn, List.of()).stream()
.map(ra -> rules.getOrDefault(region, Map.of()).get(ra))
- .filter(r -> r != null && r.isDefault())
- .forEach(r -> r.setActions(new ArrayList<>(defaultActions)));
+ .filter(r -> r != null && r.isDefault())
+ .forEach(r -> r.setActions(new ArrayList<>(defaultActions)));
+ for (Action action : defaultActions) {
+ linkTgToLb(action, listener.getLoadBalancerArn());
+ }
+ unlinkUnreferencedTargetGroups(region, listener.getLoadBalancerArn());
+ recompileRules = true;
+ }
+ persistRegion(listeners, region);
+ persistRegion(rules, region);
+ if (restartDataPlane) {
+ dataPlane.restartListener(requireListener(region, listenerArn), region, getListenerRules(region, listenerArn));
+ } else if (recompileRules) {
+ dataPlane.recompileRules(listenerArn, getListenerRules(region, listenerArn));
}
- dataPlane.stopListener(listenerArn);
- dataPlane.startListener(requireListener(region, listenerArn), region, getListenerRules(region, listenerArn));
return listener;
}
@@ -477,6 +602,7 @@ public class ElbV2Service {
rule.setDefault(false);
regionRules.put(ruleArn, rule);
+ rules.put(region, regionRules);
listenerToRules.computeIfAbsent(listenerArn, k -> new ArrayList<>()).add(ruleArn);
// update TG → LB index for all target group actions
@@ -522,6 +648,7 @@ public class ElbV2Service {
}
String listenerArn = rule.getListenerArn();
regionRules.remove(ruleArn);
+ rules.put(region, regionRules);
listenerToRules.getOrDefault(listenerArn, List.of()).remove(ruleArn);
tags.remove(ruleArn);
Listener listener = listeners.getOrDefault(region, Map.of()).get(listenerArn);
@@ -536,6 +663,7 @@ public class ElbV2Service {
String listenerArn = rule.getListenerArn();
if (conditions != null) rule.setConditions(new ArrayList<>(conditions));
if (actions != null) rule.setActions(new ArrayList<>(actions));
+ persistRegion(rules, region);
dataPlane.recompileRules(listenerArn, getListenerRules(region, listenerArn));
return rule;
}
@@ -575,6 +703,7 @@ public class ElbV2Service {
// commit
arnToPriority.forEach((arn, priority) -> regionRules.get(arn).setPriority(String.valueOf(priority)));
+ rules.put(region, regionRules);
Set<String> affectedListeners = arnToPriority.keySet().stream()
.map(arn -> regionRules.get(arn).getListenerArn())
@@ -592,6 +721,7 @@ public class ElbV2Service {
existing.removeIf(e -> e.getId().equals(t.getId()) && Objects.equals(e.getPort(), t.getPort()));
existing.add(t);
}
+ persistRegion(targetGroups, region);
healthChecker.addTargets(tgArn, targets, tg);
}
@@ -600,6 +730,7 @@ public class ElbV2Service {
for (TargetDescription t : targets) {
tg.getTargets().removeIf(e -> e.getId().equals(t.getId()) && Objects.equals(e.getPort(), t.getPort()));
}
+ persistRegion(targetGroups, region);
healthChecker.removeTargets(tgArn, targets, tg);
}
@@ -638,6 +769,7 @@ public class ElbV2Service {
public void addTags(List<String> resourceArns, Map<String, String> newTags) {
for (String arn : resourceArns) {
tags.computeIfAbsent(arn, k -> new LinkedHashMap<>()).putAll(newTags);
+ tags.put(arn, tags.get(arn));
}
}
@@ -646,6 +778,7 @@ public class ElbV2Service {
Map<String, String> resourceTags = tags.get(arn);
if (resourceTags != null) {
tagKeys.forEach(resourceTags::remove);
+ tags.put(arn, resourceTags);
}
}
}
@@ -667,11 +800,13 @@ public class ElbV2Service {
listener.getCertificates().add(certArn);
}
}
+ persistRegion(listeners, region);
}
public void removeListenerCertificates(String region, String listenerArn, List<String> certArns) {
Listener listener = requireListener(region, listenerArn);
listener.getCertificates().removeAll(certArns);
+ persistRegion(listeners, region);
}
public List<String> describeListenerCertificates(String region, String listenerArn) {
@@ -878,15 +1013,30 @@ public class ElbV2Service {
if ("forward".equals(action.getType())) {
if (action.getTargetGroupArn() != null) {
tgToLbs.computeIfAbsent(action.getTargetGroupArn(), k -> ConcurrentHashMap.newKeySet()).add(lbArn);
+ addLoadBalancerReference(action.getTargetGroupArn(), lbArn);
}
for (Action.TargetGroupTuple t : action.getTargetGroups()) {
if (t.getTargetGroupArn() != null) {
tgToLbs.computeIfAbsent(t.getTargetGroupArn(), k -> ConcurrentHashMap.newKeySet()).add(lbArn);
+ addLoadBalancerReference(t.getTargetGroupArn(), lbArn);
}
}
}
}
+ private void addLoadBalancerReference(String targetGroupArn, String loadBalancerArn) {
+ for (Map.Entry<String, Map<String, TargetGroup>> entry : targetGroups.entrySet()) {
+ TargetGroup targetGroup = entry.getValue().get(targetGroupArn);
+ if (targetGroup != null) {
+ if (!targetGroup.getLoadBalancerArns().contains(loadBalancerArn)) {
+ targetGroup.getLoadBalancerArns().add(loadBalancerArn);
+ targetGroups.put(entry.getKey(), entry.getValue());
+ }
+ return;
+ }
+ }
+ }
+
/**
* Drops {@code lbArn} from every target group that is no longer referenced by any of the
* load balancer's remaining listeners or rules. Called after a listener or rule is removed
@@ -910,10 +1060,21 @@ public class ElbV2Service {
tgToLbs.forEach((tgArn, lbSet) -> {
if (!referenced.contains(tgArn)) {
lbSet.remove(lbArn);
+ removeLoadBalancerReference(tgArn, lbArn);
}
});
}
+ private void removeLoadBalancerReference(String targetGroupArn, String loadBalancerArn) {
+ for (Map.Entry<String, Map<String, TargetGroup>> entry : targetGroups.entrySet()) {
+ TargetGroup targetGroup = entry.getValue().get(targetGroupArn);
+ if (targetGroup != null && targetGroup.getLoadBalancerArns().remove(loadBalancerArn)) {
+ targetGroups.put(entry.getKey(), entry.getValue());
+ return;
+ }
+ }
+ }
+
private static void collectActionTargetGroups(Action action, Set<String> out) {
if (action.getTargetGroupArn() != null) {
out.add(action.getTargetGroupArn());
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolver.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolver.java
new file mode 100644
index 0000000000..375f977cb0
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolver.java
@@ -0,0 +1,35 @@
+package io.github.hectorvent.floci.services.elbv2;
+
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
+import io.github.hectorvent.floci.services.ec2.model.Instance;
+import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;
+import io.github.hectorvent.floci.services.elbv2.model.TargetGroup;
+
+final class ElbV2TargetResolver {
+
+ private ElbV2TargetResolver() {}
+
+ static String resolveHost(Ec2Service ec2Service, TargetGroup targetGroup, TargetDescription target) {
+ return resolveHost(ec2Service, targetGroup, target != null ? target.getId() : null);
+ }
+
+ static String resolveHost(Ec2Service ec2Service, TargetGroup targetGroup, String targetId) {
+ if (targetId == null || targetId.isBlank()) {
+ return targetId;
+ }
+ if (targetGroup == null || !"instance".equals(targetGroup.getTargetType()) || ec2Service == null) {
+ return targetId;
+ }
+
+ Instance instance = ec2Service.findInstanceById(targetId);
+ if (instance == null) {
+ return targetId;
+ }
+
+ String containerBridgeIp = instance.getContainerBridgeIp();
+ if (containerBridgeIp != null && !containerBridgeIp.isBlank()) {
+ return containerBridgeIp;
+ }
+ return targetId;
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2IntegrationTest.java
index f47b4f94f8..7f48888802 100644
--- a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2IntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2IntegrationTest.java
@@ -38,6 +38,7 @@ class ElbV2IntegrationTest {
.formParam("Type", "application")
.formParam("Scheme", "internet-facing")
.formParam("IpAddressType", "ipv4")
+ .formParam("Subnets.member.1", "subnet-default-a")
.header("Authorization", AUTH)
.when()
.post("/")
@@ -52,6 +53,8 @@ class ElbV2IntegrationTest {
equalTo("internet-facing"))
.body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.State.Code",
equalTo("provisioning"))
+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.AvailabilityZones.member.SubnetId",
+ equalTo("subnet-default-a"))
.body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.DNSName",
containsString(".elb.localhost"))
.extract()
@@ -72,7 +75,9 @@ class ElbV2IntegrationTest {
.body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult.LoadBalancers.member.LoadBalancerArn",
equalTo(lbArn))
.body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult.LoadBalancers.member.State.Code",
- equalTo("active"));
+ equalTo("active"))
+ .body("DescribeLoadBalancersResponse.DescribeLoadBalancersResult.LoadBalancers.member.AvailabilityZones.member.SubnetId",
+ equalTo("subnet-default-a"));
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java
new file mode 100644
index 0000000000..c9fc522c61
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2ServiceTest.java
@@ -0,0 +1,264 @@
+package io.github.hectorvent.floci.services.elbv2;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
+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.elbv2.model.Action;
+import io.github.hectorvent.floci.services.elbv2.model.Listener;
+import io.github.hectorvent.floci.services.elbv2.model.Rule;
+import io.github.hectorvent.floci.services.elbv2.model.RuleCondition;
+import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;
+import io.github.hectorvent.floci.services.elbv2.model.TargetGroup;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class ElbV2ServiceTest {
+
+ private static final String REGION = "us-west-2";
+
+ @Mock
+ ElbV2DataPlane dataPlane;
+
+ @Mock
+ ElbV2HealthChecker healthChecker;
+
+ @Mock
+ Ec2Service ec2Service;
+
+ private ElbV2Service service;
+
+ @BeforeEach
+ void setUp() {
+ service = new ElbV2Service();
+ service.dataPlane = dataPlane;
+ service.healthChecker = healthChecker;
+ service.regionResolver = new RegionResolver(REGION, "000000000000");
+ service.ec2Service = ec2Service;
+ stubSubnet(ec2Service, "subnet-a", REGION + "a");
+ }
+
+ @Test
+ void modifyListenerDefaultActionsRecompilesRulesWithoutRestartingListener() {
+ String lbArn = service.createLoadBalancer(
+ REGION, "sample-lb", "internal", "application", "ipv4",
+ List.of("subnet-a"), List.of("sg-a"), Map.of()).getLoadBalancerArn();
+ String oldTgArn = createTargetGroup("sample-old-tg");
+ String newTgArn = createTargetGroup("sample-new-tg");
+ String listenerArn = service.createListener(
+ REGION, lbArn, "HTTP", 9999, null, List.of(),
+ List.of(forwardAction(oldTgArn)), List.of(), Map.of()).getListenerArn();
+ clearInvocations(dataPlane);
+
+ service.modifyListener(
+ REGION, listenerArn, null, null, null, null,
+ List.of(forwardAction(newTgArn)), null);
+
+ ArgumentCaptor<List<Rule>> rulesCaptor = ArgumentCaptor.captor();
+ verify(dataPlane).recompileRules(eq(listenerArn), rulesCaptor.capture());
+ verify(dataPlane, never()).stopListener(anyString());
+ verify(dataPlane, never()).startListener(any(Listener.class), anyString(), anyList());
+ verify(dataPlane, never()).restartListener(any(Listener.class), anyString(), anyList());
+
+ Rule defaultRule = rulesCaptor.getValue().stream()
+ .filter(Rule::isDefault)
+ .findFirst()
+ .orElseThrow();
+ assertEquals(newTgArn, defaultRule.getActions().getFirst().getTargetGroupArn());
+
+ TargetGroup oldTargetGroup = service.describeTargetGroups(REGION, null, List.of(oldTgArn), null).getFirst();
+ TargetGroup newTargetGroup = service.describeTargetGroups(REGION, null, List.of(newTgArn), null).getFirst();
+ assertFalse(oldTargetGroup.getLoadBalancerArns().contains(lbArn));
+ assertTrue(newTargetGroup.getLoadBalancerArns().contains(lbArn));
+ }
+
+ @Test
+ void modifyListenerPortRestartsListener() {
+ String lbArn = service.createLoadBalancer(
+ REGION, "sample-lb", "internal", "application", "ipv4",
+ List.of("subnet-a"), List.of("sg-a"), Map.of()).getLoadBalancerArn();
+ String tgArn = createTargetGroup("sample-tg");
+ String listenerArn = service.createListener(
+ REGION, lbArn, "HTTP", 9999, null, List.of(),
+ List.of(forwardAction(tgArn)), List.of(), Map.of()).getListenerArn();
+ clearInvocations(dataPlane);
+
+ service.modifyListener(REGION, listenerArn, null, 10000, null, null, null, null);
+
+ verify(dataPlane).restartListener(any(Listener.class), eq(REGION), anyList());
+ verify(dataPlane, never()).stopListener(anyString());
+ verify(dataPlane, never()).startListener(any(Listener.class), anyString(), anyList());
+ }
+
+ @Test
+ void initializeStorageReloadsPersistedResourcesAndRebuildsIndexes() {
+ SharedStorageFactory storageFactory = new SharedStorageFactory();
+ ElbV2DataPlane firstDataPlane = mock(ElbV2DataPlane.class);
+ ElbV2HealthChecker firstHealthChecker = mock(ElbV2HealthChecker.class);
+ ElbV2Service first = serviceWithStorage(storageFactory, firstDataPlane, firstHealthChecker);
+ String lbArn = first.createLoadBalancer(
+ REGION, "persisted-lb", "internal", "application", "ipv4",
+ List.of("subnet-a"), List.of("sg-a"), Map.of("owner", "platform")).getLoadBalancerArn();
+ String tgArn = first.createTargetGroup(
+ REGION, "persisted-tg", "HTTP", "HTTP1", 8080, "vpc-a", "instance",
+ "HTTP", "traffic-port", true, "/health", 15, 5, 3, 2, "200",
+ "ipv4", Map.of("tier", "web")).getTargetGroupArn();
+ TargetDescription target = new TargetDescription();
+ target.setId("i-1234567890abcdef0");
+ target.setPort(8080);
+ first.registerTargets(REGION, tgArn, List.of(target));
+ String listenerArn = first.createListener(
+ REGION, lbArn, "HTTP", 9080, null, List.of(),
+ List.of(forwardAction(tgArn)), List.of(), Map.of("listener", "frontdoor")).getListenerArn();
+ Rule rule = first.createRule(
+ REGION, listenerArn, List.of(pathPattern("/api/*")),
+ 10, List.of(forwardAction(tgArn)), Map.of("rule", "api"));
+ first.addTags(List.of(lbArn, tgArn, listenerArn, rule.getRuleArn()), Map.of("env", "test"));
+
+ ElbV2DataPlane reloadedDataPlane = mock(ElbV2DataPlane.class);
+ ElbV2HealthChecker reloadedHealthChecker = mock(ElbV2HealthChecker.class);
+ ElbV2Service reloaded = serviceWithStorage(storageFactory, reloadedDataPlane, reloadedHealthChecker);
+
+ assertEquals(lbArn, reloaded.describeLoadBalancers(REGION, null, List.of("persisted-lb"), null, null)
+ .getFirst().getLoadBalancerArn());
+ TargetGroup reloadedTargetGroup = reloaded.describeTargetGroups(REGION, lbArn, null, null).getFirst();
+ assertEquals(tgArn, reloadedTargetGroup.getTargetGroupArn());
+ assertEquals(List.of(lbArn), reloadedTargetGroup.getLoadBalancerArns());
+ assertEquals("i-1234567890abcdef0", reloadedTargetGroup.getTargets().getFirst().getId());
+ Listener reloadedListener = reloaded.describeListeners(REGION, lbArn, null).getFirst();
+ assertEquals(listenerArn, reloadedListener.getListenerArn());
+ List<Rule> reloadedRules = reloaded.describeRules(REGION, listenerArn, null);
+ assertEquals(2, reloadedRules.size());
+ assertTrue(reloadedRules.stream().anyMatch(Rule::isDefault));
+ assertTrue(reloadedRules.stream().anyMatch(candidate -> "10".equals(candidate.getPriority())));
+ assertEquals("test", reloaded.describeTags(List.of(lbArn)).get(lbArn).get("env"));
+ assertThrows(AwsException.class, () -> reloaded.deleteTargetGroup(REGION, tgArn));
+ verify(reloadedHealthChecker).startMonitoring(any(TargetGroup.class));
+ ArgumentCaptor<List<TargetDescription>> targetsCaptor = ArgumentCaptor.captor();
+ verify(reloadedHealthChecker).addTargets(eq(tgArn), targetsCaptor.capture(), any(TargetGroup.class));
+ assertEquals("i-1234567890abcdef0", targetsCaptor.getValue().getFirst().getId());
+ assertEquals(8080, targetsCaptor.getValue().getFirst().getPort());
+ verify(reloadedDataPlane).startListener(any(Listener.class), eq(REGION), anyList());
+
+ reloaded.removeTags(List.of(rule.getRuleArn()), List.of("env"));
+ ElbV2Service updatedReload = serviceWithStorage(storageFactory, mock(ElbV2DataPlane.class), mock(ElbV2HealthChecker.class));
+ assertFalse(updatedReload.describeTags(List.of(rule.getRuleArn()))
+ .get(rule.getRuleArn()).containsKey("env"));
+ }
+
+ @Test
+ void initializeStorageStartsPersistedListenersWithoutTargetGroups() {
+ SharedStorageFactory storageFactory = new SharedStorageFactory();
+ ElbV2Service first = serviceWithStorage(storageFactory, mock(ElbV2DataPlane.class), mock(ElbV2HealthChecker.class));
+ String lbArn = first.createLoadBalancer(
+ REGION, "listener-only-lb", "internal", "application", "ipv4",
+ List.of("subnet-a"), List.of("sg-a"), Map.of()).getLoadBalancerArn();
+ String listenerArn = first.createListener(
+ REGION, lbArn, "HTTP", 8080, null, List.of(),
+ List.of(), List.of(), Map.of()).getListenerArn();
+
+ ElbV2DataPlane reloadedDataPlane = mock(ElbV2DataPlane.class);
+ serviceWithStorage(storageFactory, reloadedDataPlane, mock(ElbV2HealthChecker.class));
+
+ ArgumentCaptor<Listener> listenerCaptor = ArgumentCaptor.captor();
+ verify(reloadedDataPlane).startListener(listenerCaptor.capture(), eq(REGION), anyList());
+ assertEquals(listenerArn, listenerCaptor.getValue().getListenerArn());
+ }
+
+ private String createTargetGroup(String name) {
+ return service.createTargetGroup(
+ REGION, name, "HTTP", "HTTP1", 9999, "vpc-a", "instance",
+ "HTTP", "traffic-port", true, "/v1/ready", 30, 5, 5, 2, "200",
+ "ipv4", Map.of()).getTargetGroupArn();
+ }
+
+ private static Action forwardAction(String targetGroupArn) {
+ Action action = new Action();
+ action.setType("forward");
+ action.setTargetGroupArn(targetGroupArn);
+ return action;
+ }
+
+ private static RuleCondition pathPattern(String value) {
+ RuleCondition condition = new RuleCondition();
+ condition.setField("path-pattern");
+ condition.setValues(List.of(value));
+ condition.setPathPatternValues(List.of(value));
+ return condition;
+ }
+
+ private static ElbV2Service serviceWithStorage(StorageFactory storageFactory,
+ ElbV2DataPlane dataPlane,
+ ElbV2HealthChecker healthChecker) {
+ Ec2Service ec2Service = mock(Ec2Service.class);
+ stubSubnet(ec2Service, "subnet-a", REGION + "a");
+ return serviceWithStorage(storageFactory, dataPlane, healthChecker, ec2Service);
+ }
+
+ private static ElbV2Service serviceWithStorage(StorageFactory storageFactory,
+ ElbV2DataPlane dataPlane,
+ ElbV2HealthChecker healthChecker,
+ Ec2Service ec2Service) {
+ ElbV2Service service = new ElbV2Service();
+ service.dataPlane = dataPlane;
+ service.healthChecker = healthChecker;
+ service.regionResolver = new RegionResolver(REGION, "000000000000");
+ service.ec2Service = ec2Service;
+ service.storageFactory = storageFactory;
+ service.initializeStorage();
+ return service;
+ }
+
+ private static void stubSubnet(Ec2Service ec2Service, String subnetId, String availabilityZone) {
+ Subnet subnet = new Subnet();
+ subnet.setSubnetId(subnetId);
+ subnet.setAvailabilityZone(availabilityZone);
+ subnet.setVpcId("vpc-a");
+ lenient().when(ec2Service.requireSubnet(REGION, subnetId)).thenReturn(subnet);
+ lenient().when(ec2Service.describeSubnets(eq(REGION), eq(List.of(subnetId)), eq(Map.of())))
+ .thenReturn(List.of(subnet));
+ }
+
+ private static final class SharedStorageFactory extends StorageFactory {
+ private final Map<String, StorageBackend<String, ?>> stores = new HashMap<>();
+
+ private SharedStorageFactory() {
+ super(null, null);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public <V> StorageBackend<String, V> create(String serviceName,
+ String fileName,
+ TypeReference<Map<String, V>> typeReference) {
+ return (StorageBackend<String, V>) stores.computeIfAbsent(fileName, ignored -> new InMemoryStorage<>());
+ }
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolverTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolverTest.java
new file mode 100644
index 0000000000..cd3ddc65cf
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolverTest.java
@@ -0,0 +1,41 @@
+package io.github.hectorvent.floci.services.elbv2;
+
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
+import io.github.hectorvent.floci.services.ec2.model.Instance;
+import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;
+import io.github.hectorvent.floci.services.elbv2.model.TargetGroup;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class ElbV2TargetResolverTest {
+
+ @Test
+ void instanceTargetResolvesToBackingContainerBridgeIp() {
+ Ec2Service ec2Service = mock(Ec2Service.class);
+ Instance instance = new Instance();
+ instance.setInstanceId("i-1234567890abcdef0");
+ instance.setContainerBridgeIp("172.18.0.42");
+ when(ec2Service.findInstanceById("i-1234567890abcdef0")).thenReturn(instance);
+
+ TargetGroup targetGroup = new TargetGroup();
+ targetGroup.setTargetType("instance");
+ TargetDescription target = new TargetDescription();
+ target.setId("i-1234567890abcdef0");
+
+ assertEquals("172.18.0.42", ElbV2TargetResolver.resolveHost(ec2Service, targetGroup, target));
+ }
+
+ @Test
+ void ipTargetKeepsRegisteredAddress() {
+ Ec2Service ec2Service = mock(Ec2Service.class);
+ TargetGroup targetGroup = new TargetGroup();
+ targetGroup.setTargetType("ip");
+ TargetDescription target = new TargetDescription();
+ target.setId("10.0.0.12");
+
+ assertEquals("10.0.0.12", ElbV2TargetResolver.resolveHost(ec2Service, targetGroup, target));
+ }
+}