Light, fluffy, and always free - The AWS Local Emulator alternative
feat(autoscaling): support group reconciliation and refresh (#1393)
Jason van Zyl56706217d32b
diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 5562b4d09b..a42acaf15b 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -45,7 +45,9 @@ Key pairs created with `CreateKeyPair` contain dummy private key material. Impor## UserData-`UserData` must be base64-encoded in the request (matching the AWS wire format). Floci decodes it, copies the script into `/tmp/user-data.sh` inside the container, and executes it with `sh` after SSH key injection. Output is captured and logged.+`UserData` must be base64-encoded in the request (matching the AWS wire format). Floci decodes it, copies the script into `/tmp/user-data.sh` inside the container, and executes the script directly after SSH key injection so the script shebang selects the interpreter. Output is captured and logged.++EC2 containers receive `AWS_EC2_METADATA_SERVICE_ENDPOINT` for IMDS and `AWS_ENDPOINT_URL` for AWS service API calls back to Floci.## Instance Metadata Service (IMDS)@@ -143,7 +145,9 @@ Floci seeds the following resources on first use in each region so Terraform, th`DescribeInstanceTypes` · `DescribeInstanceTypeOfferings`### Launch Templates-`CreateLaunchTemplate` · `DescribeLaunchTemplates` · `DeleteLaunchTemplate`+`CreateLaunchTemplate` · `CreateLaunchTemplateVersion` · `DescribeLaunchTemplates` · `DescribeLaunchTemplateVersions` · `ModifyLaunchTemplate` · `DeleteLaunchTemplate`++Launch templates store versioned launch data. New template versions can be created from an existing source version, and `ModifyLaunchTemplate` updates the default version used by later launches.### IAM Instance Profiles`DescribeIamInstanceProfileAssociations`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 c6f9016222..a0b3b2fa86 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@@ -113,6 +113,7 @@ public class AwsQueryController {"CreateLaunchConfiguration", "DescribeLaunchConfigurations", "DeleteLaunchConfiguration","CreateAutoScalingGroup", "UpdateAutoScalingGroup", "DeleteAutoScalingGroup","DescribeAutoScalingGroups", "SetDesiredCapacity",+ "StartInstanceRefresh", "DescribeInstanceRefreshes","CreateOrUpdateTags", "DeleteTags","DescribeAutoScalingInstances", "AttachInstances", "DetachInstances","TerminateInstanceInAutoScalingGroup",diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.javaindex 727f86641a..9c03fbb9b3 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandler.java@@ -44,6 +44,10 @@ public class AutoScalingQueryHandler {case "DeleteAutoScalingGroup" -> handleDeleteAutoScalingGroup(p, region);case "DescribeAutoScalingGroups" -> handleDescribeAutoScalingGroups(p, region);case "SetDesiredCapacity" -> handleSetDesiredCapacity(p, region);+ case "StartInstanceRefresh" -> handleStartInstanceRefresh(p, region);+ case "DescribeInstanceRefreshes" -> handleDescribeInstanceRefreshes(p, region);+ case "CreateOrUpdateTags" -> handleCreateOrUpdateTags(p, region);+ case "DeleteTags" -> handleDeleteTags(p, region);// Instancescase "DescribeAutoScalingInstances" -> handleDescribeAutoScalingInstances(p, region);case "AttachInstances" -> handleAttachInstances(p, region);@@ -149,6 +153,7 @@ public class AutoScalingQueryHandler {service.createAutoScalingGroup(region,p.getFirst("AutoScalingGroupName"),p.getFirst("LaunchConfigurationName"),+ p.getFirst("LaunchTemplate.LaunchTemplateId"),p.getFirst("LaunchTemplate.LaunchTemplateName"),p.getFirst("LaunchTemplate.Version"),intParam(p, "MinSize", 0),@@ -156,6 +161,7 @@ public class AutoScalingQueryHandler {intParam(p, "DesiredCapacity", intParam(p, "MinSize", 0)),intParam(p, "DefaultCooldown", 300),memberList(p, "AvailabilityZones"),+ commaList(p.getFirst("VPCZoneIdentifier")),memberList(p, "TargetGroupARNs"),memberList(p, "LoadBalancerNames"),p.getFirst("HealthCheckType"),@@ -171,9 +177,11 @@ public class AutoScalingQueryHandler {private Response handleUpdateAutoScalingGroup(MultivaluedMap<String, String> p, String region) {List<String> azs = memberList(p, "AvailabilityZones");List<String> tps = memberList(p, "TerminationPolicies");+ List<String> subnetIds = commaList(p.getFirst("VPCZoneIdentifier"));service.updateAutoScalingGroup(region,p.getFirst("AutoScalingGroupName"),p.getFirst("LaunchConfigurationName"),+ p.getFirst("LaunchTemplate.LaunchTemplateId"),p.getFirst("LaunchTemplate.LaunchTemplateName"),p.getFirst("LaunchTemplate.Version"),p.getFirst("MinSize") != null ? Integer.parseInt(p.getFirst("MinSize")) : null,@@ -181,6 +189,7 @@ public class AutoScalingQueryHandler {p.getFirst("DesiredCapacity") != null ? Integer.parseInt(p.getFirst("DesiredCapacity")) : null,p.getFirst("DefaultCooldown") != null ? Integer.parseInt(p.getFirst("DefaultCooldown")) : null,azs.isEmpty() ? null : azs,+ subnetIds.isEmpty() ? null : subnetIds,p.getFirst("HealthCheckType"),p.getFirst("HealthCheckGracePeriod") != null ? Integer.parseInt(p.getFirst("HealthCheckGracePeriod")) : null,tps.isEmpty() ? null : tps);@@ -233,9 +242,14 @@ public class AutoScalingQueryHandler {if (asg.getLaunchConfigurationName() != null) {xml.elem("LaunchConfigurationName", asg.getLaunchConfigurationName());}- if (asg.getLaunchTemplateName() != null) {- xml.start("LaunchTemplate")- .elem("LaunchTemplateName", asg.getLaunchTemplateName());+ if (asg.getLaunchTemplateId() != null || asg.getLaunchTemplateName() != null) {+ xml.start("LaunchTemplate");+ if (asg.getLaunchTemplateId() != null) {+ xml.elem("LaunchTemplateId", asg.getLaunchTemplateId());+ }+ if (asg.getLaunchTemplateName() != null) {+ xml.elem("LaunchTemplateName", asg.getLaunchTemplateName());+ }if (asg.getLaunchTemplateVersion() != null) {xml.elem("Version", asg.getLaunchTemplateVersion());}@@ -246,6 +260,10 @@ public class AutoScalingQueryHandler {for (String az : asg.getAvailabilityZones()) { xml.elem("member", az); }xml.end("AvailabilityZones");+ if (!asg.getSubnetIds().isEmpty()) {+ xml.elem("VPCZoneIdentifier", String.join(",", asg.getSubnetIds()));+ }+xml.start("TargetGroupARNs");for (String arn : asg.getTargetGroupARNs()) { xml.elem("member", arn); }xml.end("TargetGroupARNs");@@ -269,6 +287,7 @@ public class AutoScalingQueryHandler {if (inst.getLaunchConfigurationName() != null) {xml.elem("LaunchConfigurationName", inst.getLaunchConfigurationName());}+ appendInstanceLaunchTemplateXml(xml, inst);if (inst.getInstanceType() != null) { xml.elem("InstanceType", inst.getInstanceType()); }xml.end("member");}@@ -299,6 +318,115 @@ public class AutoScalingQueryHandler {.end("SetDesiredCapacityResponse").build());}+ private Response handleStartInstanceRefresh(MultivaluedMap<String, String> p, String region) {+ InstanceRefresh refresh = service.startInstanceRefresh(region,+ p.getFirst("AutoScalingGroupName"), parseInstanceRefresh(p));+ return ok(new XmlBuilder()+ .start("StartInstanceRefreshResponse", NS)+ .start("StartInstanceRefreshResult")+ .elem("InstanceRefreshId", refresh.getInstanceRefreshId())+ .end("StartInstanceRefreshResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("StartInstanceRefreshResponse").build());+ }++ private Response handleDescribeInstanceRefreshes(MultivaluedMap<String, String> p, String region) {+ AutoScalingService.InstanceRefreshPage page = service.describeInstanceRefreshes(region,+ p.getFirst("AutoScalingGroupName"),+ memberList(p, "InstanceRefreshIds"),+ nullableIntParam(p, "MaxRecords"),+ p.getFirst("NextToken"));+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeInstanceRefreshesResponse", NS)+ .start("DescribeInstanceRefreshesResult")+ .start("InstanceRefreshes");+ for (InstanceRefresh refresh : page.instanceRefreshes()) {+ appendInstanceRefreshXml(xml, refresh);+ }+ xml.end("InstanceRefreshes");+ if (page.nextToken() != null) {+ xml.elem("NextToken", page.nextToken());+ }+ xml.end("DescribeInstanceRefreshesResult")+ .raw(AwsQueryResponse.responseMetadata())+ .end("DescribeInstanceRefreshesResponse");+ return ok(xml.build());+ }++ private void appendInstanceRefreshXml(XmlBuilder xml, InstanceRefresh refresh) {+ xml.start("member")+ .elem("InstanceRefreshId", refresh.getInstanceRefreshId())+ .elem("AutoScalingGroupName", refresh.getAutoScalingGroupName())+ .elem("Status", refresh.getStatus())+ .elem("StatusReason", refresh.getStatusReason())+ .elem("PercentageComplete", String.valueOf(refresh.getPercentageComplete()))+ .elem("InstancesToUpdate", String.valueOf(refresh.getInstancesToUpdate()))+ .elem("StartTime", ISO_FMT.format(refresh.getStartTime()));+ if (refresh.getEndTime() != null) {+ xml.elem("EndTime", ISO_FMT.format(refresh.getEndTime()));+ }+ if (refresh.getStrategy() != null) {+ xml.elem("Strategy", refresh.getStrategy());+ }+ appendDesiredConfigurationXml(xml, refresh);+ appendPreferencesXml(xml, refresh);+ xml.end("member");+ }++ private void appendDesiredConfigurationXml(XmlBuilder xml, InstanceRefresh refresh) {+ if (!refresh.hasDesiredConfiguration()) {+ return;+ }+ xml.start("DesiredConfiguration")+ .start("LaunchTemplate")+ .elem("LaunchTemplateId", refresh.getDesiredLaunchTemplateId())+ .elem("LaunchTemplateName", refresh.getDesiredLaunchTemplateName())+ .elem("Version", refresh.getDesiredLaunchTemplateVersion())+ .end("LaunchTemplate")+ .end("DesiredConfiguration");+ }++ private void appendPreferencesXml(XmlBuilder xml, InstanceRefresh refresh) {+ xml.start("Preferences")+ .elem("MinHealthyPercentage", intString(refresh.getMinHealthyPercentage()))+ .elem("MaxHealthyPercentage", intString(refresh.getMaxHealthyPercentage()))+ .elem("InstanceWarmup", intString(refresh.getInstanceWarmup()))+ .elem("SkipMatching", boolString(refresh.getSkipMatching()))+ .elem("AutoRollback", boolString(refresh.getAutoRollback()))+ .elem("ScaleInProtectedInstances", refresh.getScaleInProtectedInstances())+ .elem("StandbyInstances", refresh.getStandbyInstances())+ .elem("CheckpointDelay", intString(refresh.getCheckpointDelay()))+ .elem("BakeTime", intString(refresh.getBakeTime()));+ if (!refresh.getCheckpointPercentages().isEmpty()) {+ xml.start("CheckpointPercentages");+ for (Integer percentage : refresh.getCheckpointPercentages()) {+ xml.elem("member", String.valueOf(percentage));+ }+ xml.end("CheckpointPercentages");+ }+ xml.end("Preferences");+ }++ private Response handleCreateOrUpdateTags(MultivaluedMap<String, String> p, String region) {+ for (TagRequest tag : parseTagRequests(p)) {+ service.createOrUpdateTags(region, tag.resourceId(), tag.resourceType(), Map.of(tag.key(), tag.value()));+ }+ return ok(new XmlBuilder()+ .start("CreateOrUpdateTagsResponse", NS)+ .raw(AwsQueryResponse.responseMetadata())+ .end("CreateOrUpdateTagsResponse").build());+ }++ private Response handleDeleteTags(MultivaluedMap<String, String> p, String region) {+ for (TagRequest tag : parseTagRequests(p)) {+ service.deleteTags(region, tag.resourceId(), tag.resourceType(), List.of(tag.key()));+ }+ return ok(new XmlBuilder()+ .start("DeleteTagsResponse", NS)+ .raw(AwsQueryResponse.responseMetadata())+ .end("DeleteTagsResponse").build());+ }+// ── Instances ─────────────────────────────────────────────────────────────private Response handleDescribeAutoScalingInstances(MultivaluedMap<String, String> p, String region) {@@ -318,16 +446,34 @@ public class AutoScalingQueryHandler {if (inst.getLaunchConfigurationName() != null) {xml.elem("LaunchConfigurationName", inst.getLaunchConfigurationName());}+ appendInstanceLaunchTemplateXml(xml, inst);if (inst.getInstanceType() != null) { xml.elem("InstanceType", inst.getInstanceType()); }xml.end("member");}xml.end("AutoScalingInstances").end("DescribeAutoScalingInstancesResult")- .raw(AwsQueryResponse.responseMetadata())- .end("DescribeAutoScalingInstancesResponse");+ .raw(AwsQueryResponse.responseMetadata())+ .end("DescribeAutoScalingInstancesResponse");return ok(xml.build());}+ private static void appendInstanceLaunchTemplateXml(XmlBuilder xml, AsgInstance inst) {+ if (inst.getLaunchTemplateId() == null && inst.getLaunchTemplateName() == null) {+ return;+ }+ xml.start("LaunchTemplate");+ if (inst.getLaunchTemplateId() != null) {+ xml.elem("LaunchTemplateId", inst.getLaunchTemplateId());+ }+ if (inst.getLaunchTemplateName() != null) {+ xml.elem("LaunchTemplateName", inst.getLaunchTemplateName());+ }+ if (inst.getLaunchTemplateVersion() != null) {+ xml.elem("Version", inst.getLaunchTemplateVersion());+ }+ xml.end("LaunchTemplate");+ }+private Response handleAttachInstances(MultivaluedMap<String, String> p, String region) {service.attachInstances(region, p.getFirst("AutoScalingGroupName"), memberList(p, "InstanceIds"));return ok(new XmlBuilder()@@ -709,6 +855,16 @@ public class AutoScalingQueryHandler {return result;}+ private List<String> commaList(String value) {+ if (value == null || value.isBlank()) {+ return List.of();+ }+ return Arrays.stream(value.split(","))+ .map(String::trim)+ .filter(item -> !item.isEmpty())+ .toList();+ }+private Map<String, String> parseTags(MultivaluedMap<String, String> p) {Map<String, String> result = new LinkedHashMap<>();for (int i = 1; ; i++) {@@ -720,12 +876,78 @@ public class AutoScalingQueryHandler {return result;}+ private List<TagRequest> parseTagRequests(MultivaluedMap<String, String> p) {+ List<TagRequest> result = new ArrayList<>();+ for (int i = 1; ; i++) {+ String key = p.getFirst("Tags.member." + i + ".Key");+ if (key == null) { break; }+ String resourceId = p.getFirst("Tags.member." + i + ".ResourceId");+ String resourceType = p.getFirst("Tags.member." + i + ".ResourceType");+ String value = p.getFirst("Tags.member." + i + ".Value");+ result.add(new TagRequest(resourceId, resourceType, key, value != null ? value : ""));+ }+ return result;+ }++ private record TagRequest(String resourceId, String resourceType, String key, String value) {}++ private InstanceRefresh parseInstanceRefresh(MultivaluedMap<String, String> p) {+ InstanceRefresh refresh = new InstanceRefresh();+ refresh.setStrategy(p.getFirst("Strategy"));+ refresh.setDesiredLaunchTemplateId(p.getFirst("DesiredConfiguration.LaunchTemplate.LaunchTemplateId"));+ refresh.setDesiredLaunchTemplateName(p.getFirst("DesiredConfiguration.LaunchTemplate.LaunchTemplateName"));+ refresh.setDesiredLaunchTemplateVersion(p.getFirst("DesiredConfiguration.LaunchTemplate.Version"));+ refresh.setMinHealthyPercentage(nullableIntParam(p, "Preferences.MinHealthyPercentage"));+ refresh.setMaxHealthyPercentage(nullableIntParam(p, "Preferences.MaxHealthyPercentage"));+ refresh.setInstanceWarmup(nullableIntParam(p, "Preferences.InstanceWarmup"));+ refresh.setSkipMatching(nullableBoolParam(p, "Preferences.SkipMatching"));+ refresh.setAutoRollback(nullableBoolParam(p, "Preferences.AutoRollback"));+ refresh.setScaleInProtectedInstances(p.getFirst("Preferences.ScaleInProtectedInstances"));+ refresh.setStandbyInstances(p.getFirst("Preferences.StandbyInstances"));+ refresh.setCheckpointDelay(nullableIntParam(p, "Preferences.CheckpointDelay"));+ refresh.setBakeTime(nullableIntParam(p, "Preferences.BakeTime"));+ refresh.setCheckpointPercentages(memberIntList(p, "Preferences.CheckpointPercentages"));+ return refresh;+ }++ private List<Integer> memberIntList(MultivaluedMap<String, String> p, String prefix) {+ List<Integer> result = new ArrayList<>();+ for (String value : memberList(p, prefix)) {+ try {+ result.add(Integer.parseInt(value));+ } catch (NumberFormatException ignored) {+ // Keep Query parsing permissive like the existing integer helpers.+ }+ }+ return result;+ }+private int intParam(MultivaluedMap<String, String> p, String key, int defaultValue) {String val = p.getFirst(key);if (val == null || val.isBlank()) { return defaultValue; }try { return Integer.parseInt(val); } catch (NumberFormatException e) { return defaultValue; }}+ private Integer nullableIntParam(MultivaluedMap<String, String> p, String key) {+ String val = p.getFirst(key);+ if (val == null || val.isBlank()) { return null; }+ try { return Integer.parseInt(val); } catch (NumberFormatException e) { return null; }+ }++ private Boolean nullableBoolParam(MultivaluedMap<String, String> p, String key) {+ String val = p.getFirst(key);+ if (val == null || val.isBlank()) { return null; }+ return Boolean.parseBoolean(val);+ }++ private String intString(Integer value) {+ return value != null ? String.valueOf(value) : null;+ }++ private String boolString(Boolean value) {+ return value != null ? String.valueOf(value) : null;+ }+private Response ok(String xml) {return Response.ok(xml).type("application/xml").build();}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 4a00f7c030..4d00dd2d41 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@@ -5,15 +5,21 @@ import io.github.hectorvent.floci.services.autoscaling.model.AutoScalingGroup;import io.github.hectorvent.floci.services.autoscaling.model.LaunchConfiguration;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.elbv2.ElbV2Service;import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;+import io.github.hectorvent.floci.services.elbv2.model.TargetHealth;import jakarta.annotation.PostConstruct;import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.event.Observes;import jakarta.inject.Inject;import org.jboss.logging.Logger;+import io.quarkus.runtime.StartupEvent;import java.util.List;+import java.util.Map;+import java.util.Set;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;@@ -43,6 +49,10 @@ public class AutoScalingReconciler {scheduler.scheduleAtFixedRate(this::reconcileAll, 5, 10, TimeUnit.SECONDS);}+ void onStart(@Observes StartupEvent event) {+ LOG.debug("Auto Scaling reconciler initialized");+ }+void reconcileAll() {for (AutoScalingGroup asg : asgService.describeAutoScalingGroups(null, null)) {try {@@ -54,21 +64,34 @@ public class AutoScalingReconciler {}public void reconcile(AutoScalingGroup asg) {+ removeTerminatingInstances(asg);+ removeStaleInstances(asg);+ removeOrphanedTargetRegistrations(asg);promoteReadyInstances(asg);- long inService = asg.getInstances().stream()- .filter(i -> "InService".equals(i.getLifecycleState()))- .count();+ long activeCapacity = activeCapacity(asg);int desired = asg.getDesiredCapacity();- if (inService < desired) {- scaleOut(asg, (int) (desired - inService));- } else if (inService > desired) {- scaleIn(asg, (int) (inService - desired));+ if (activeCapacity < desired) {+ scaleOut(asg, (int) (desired - activeCapacity));+ } else if (activeCapacity > desired) {+ scaleIn(asg, (int) (activeCapacity - desired));}+ asgService.saveAutoScalingGroup(asg);+ asgService.completeInstanceRefreshIfSettled(asg.getRegion(), asg.getAutoScalingGroupName());+ }++ static long activeCapacity(AutoScalingGroup asg) {+ return asg.getInstances().stream()+ .filter(i -> {+ String state = i.getLifecycleState();+ return "Pending".equals(state) || "InService".equals(state);+ })+ .count();}private void promoteReadyInstances(AutoScalingGroup asg) {+ boolean changed = false;for (AsgInstance asgInst : asg.getInstances()) {if (!"Pending".equals(asgInst.getLifecycleState())) {continue;@@ -85,6 +108,7 @@ public class AutoScalingReconciler {asgInst.setLifecycleState("InService");asgInst.setHealthStatus("Healthy");registerWithTargetGroups(asg, asgInst);+ changed = true;asgService.recordActivity(asg.getRegion(), asg.getAutoScalingGroupName(),"Launching a new EC2 instance: " + asgInst.getInstanceId(),"An instance was started in response to a desired capacity change.",@@ -97,31 +121,122 @@ public class AutoScalingReconciler {asg.getAutoScalingGroupName(), asgInst.getInstanceId(), e.getMessage());}}+ if (changed) {+ asgService.saveAutoScalingGroup(asg);+ }+ }++ private void removeStaleInstances(AutoScalingGroup asg) {+ List<AsgInstance> staleInstances = asg.getInstances().stream()+ .filter(instance -> isActiveLifecycleState(instance.getLifecycleState()))+ .filter(instance -> !ec2Service.isInstanceContainerRunning(instance.getInstanceId()))+ .collect(Collectors.toList());+ if (staleInstances.isEmpty()) {+ return;+ }++ List<String> instanceIds = staleInstances.stream()+ .map(AsgInstance::getInstanceId)+ .collect(Collectors.toList());+ asg.getInstances().removeIf(instance -> instanceIds.contains(instance.getInstanceId()));+ asgService.saveAutoScalingGroup(asg);+ asgService.recordActivity(asg.getRegion(), asg.getAutoScalingGroupName(),+ "Removing stale EC2 instance reference(s): " + instanceIds,+ "Persisted Auto Scaling state referenced instance containers that are no longer running.",+ "Successful");+ LOG.infov("ASG {0}: removed stale instance reference(s) {1}",+ asg.getAutoScalingGroupName(), instanceIds);+ }++ private void removeOrphanedTargetRegistrations(AutoScalingGroup asg) {+ if (asg.getTargetGroupARNs().isEmpty()) {+ return;+ }++ Set<String> activeInstanceIds = asg.getInstances().stream()+ .filter(instance -> isActiveLifecycleState(instance.getLifecycleState()))+ .map(AsgInstance::getInstanceId)+ .collect(Collectors.toSet());++ for (String tgArn : asg.getTargetGroupARNs()) {+ try {+ List<TargetDescription> orphanedTargets = elbV2Service.describeTargetHealth(+ asg.getRegion(), tgArn, List.of()).stream()+ .map(TargetHealth::getTarget)+ .filter(target -> target != null && target.getId() != null)+ .filter(target -> !activeInstanceIds.contains(target.getId()))+ .collect(Collectors.toList());+ if (!orphanedTargets.isEmpty()) {+ elbV2Service.deregisterTargets(asg.getRegion(), tgArn, orphanedTargets);+ LOG.infov("ASG {0}: deregistered orphaned target(s) {1} from TG {2}",+ asg.getAutoScalingGroupName(),+ orphanedTargets.stream().map(TargetDescription::getId).collect(Collectors.toList()),+ tgArn);+ }+ } catch (Exception e) {+ LOG.debugv("ASG {0}: could not reconcile TG {1}: {2}",+ asg.getAutoScalingGroupName(), tgArn, e.getMessage());+ }+ }+ }++ private void removeTerminatingInstances(AutoScalingGroup asg) {+ List<AsgInstance> terminatingInstances = asg.getInstances().stream()+ .filter(instance -> "Terminating".equals(instance.getLifecycleState()))+ .collect(Collectors.toList());+ if (terminatingInstances.isEmpty()) {+ return;+ }++ List<String> instanceIds = terminatingInstances.stream()+ .map(AsgInstance::getInstanceId)+ .collect(Collectors.toList());+ deregisterFromTargetGroups(asg, instanceIds);+ try {+ ec2Service.terminateInstances(asg.getRegion(), instanceIds);+ } catch (Exception e) {+ LOG.warnv("ASG {0}: failed to terminate refreshing instances {1}: {2}",+ asg.getAutoScalingGroupName(), instanceIds, e.getMessage());+ }++ asg.getInstances().removeIf(instance -> instanceIds.contains(instance.getInstanceId()));+ asgService.saveAutoScalingGroup(asg);+ asgService.recordActivity(asg.getRegion(), asg.getAutoScalingGroupName(),+ "Terminating EC2 instance(s) for refresh: " + instanceIds,+ "An instance refresh requested replacement of active instances.",+ "Successful");+ LOG.infov("ASG {0}: terminated instance(s) for refresh {1}",+ asg.getAutoScalingGroupName(), instanceIds);+ }++ private static boolean isActiveLifecycleState(String state) {+ return "Pending".equals(state) || "InService".equals(state);}private void scaleOut(AutoScalingGroup asg, int count) {- LaunchConfiguration lc = resolveLaunchConfiguration(asg);- if (lc == null) {- LOG.warnv("ASG {0}: no launch configuration found, cannot scale out", asg.getAutoScalingGroupName());+ LaunchSource launchSource = resolveLaunchSource(asg);+ if (launchSource == null) {+ LOG.warnv("ASG {0}: no launch source found, cannot scale out", asg.getAutoScalingGroupName());return;}LOG.infov("ASG {0}: scaling out by {1}", asg.getAutoScalingGroupName(), count);String az = asg.getAvailabilityZones().isEmpty()? asg.getRegion() + "a": asg.getAvailabilityZones().get(0);+ String subnetId = asg.getSubnetIds().isEmpty() ? null : asg.getSubnetIds().get(0);try {Reservation reservation = ec2Service.runInstances(asg.getRegion(),- lc.getImageId(),- lc.getInstanceType(),+ launchSource.imageId(),+ launchSource.instanceType(),count, count,- lc.getKeyName(),- lc.getSecurityGroups(),- null,+ launchSource.keyName(),+ launchSource.securityGroupIds(),+ subnetId,null,- null,- lc.getUserData(),- lc.getIamInstanceProfile());+ launchSource.instanceTags(),+ launchSource.userData(),+ launchSource.iamInstanceProfile());for (Instance ec2Inst : reservation.getInstances()) {AsgInstance asgInst = new AsgInstance();@@ -129,12 +244,16 @@ public class AutoScalingReconciler {asgInst.setAvailabilityZone(az);asgInst.setLifecycleState("Pending");asgInst.setHealthStatus("Healthy");- asgInst.setLaunchConfigurationName(lc.getLaunchConfigurationName());- asgInst.setInstanceType(lc.getInstanceType());+ asgInst.setLaunchConfigurationName(launchSource.launchConfigurationName());+ asgInst.setLaunchTemplateId(launchSource.launchTemplateId());+ asgInst.setLaunchTemplateName(launchSource.launchTemplateName());+ asgInst.setLaunchTemplateVersion(launchSource.launchTemplateVersion());+ asgInst.setInstanceType(launchSource.instanceType());asg.getInstances().add(asgInst);LOG.infov("ASG {0}: launched instance {1} (Pending)",asg.getAutoScalingGroupName(), ec2Inst.getInstanceId());}+ asgService.saveAutoScalingGroup(asg);} catch (Exception e) {LOG.warnv("ASG {0}: failed to launch instances: {1}",asg.getAutoScalingGroupName(), e.getMessage());@@ -157,18 +276,7 @@ public class AutoScalingReconciler {.map(AsgInstance::getInstanceId).collect(Collectors.toList());- // Deregister from all attached target groups first- for (String tgArn : asg.getTargetGroupARNs()) {- try {- List<TargetDescription> targets = instanceIds.stream()- .map(id -> { TargetDescription td = new TargetDescription(); td.setId(id); return td; })- .collect(Collectors.toList());- elbV2Service.deregisterTargets(asg.getRegion(), tgArn, targets);- } catch (Exception e) {- LOG.debugv("ASG {0}: could not deregister from TG {1}: {2}",- asg.getAutoScalingGroupName(), tgArn, e.getMessage());- }- }+ deregisterFromTargetGroups(asg, instanceIds);try {ec2Service.terminateInstances(asg.getRegion(), instanceIds);@@ -178,12 +286,27 @@ public class AutoScalingReconciler {}asg.getInstances().removeIf(i -> instanceIds.contains(i.getInstanceId()));+ asgService.saveAutoScalingGroup(asg);asgService.recordActivity(asg.getRegion(), asg.getAutoScalingGroupName(),"Terminating EC2 instance(s): " + instanceIds,"An instance was terminated in response to a desired capacity change.","Successful");}+ private void deregisterFromTargetGroups(AutoScalingGroup asg, List<String> instanceIds) {+ for (String tgArn : asg.getTargetGroupARNs()) {+ try {+ List<TargetDescription> targets = instanceIds.stream()+ .map(id -> { TargetDescription td = new TargetDescription(); td.setId(id); return td; })+ .collect(Collectors.toList());+ elbV2Service.deregisterTargets(asg.getRegion(), tgArn, targets);+ } catch (Exception e) {+ LOG.debugv("ASG {0}: could not deregister from TG {1}: {2}",+ asg.getAutoScalingGroupName(), tgArn, e.getMessage());+ }+ }+ }+private void registerWithTargetGroups(AutoScalingGroup asg, AsgInstance asgInst) {for (String tgArn : asg.getTargetGroupARNs()) {try {@@ -199,6 +322,51 @@ public class AutoScalingReconciler {}}+ private LaunchSource resolveLaunchSource(AutoScalingGroup asg) {+ LaunchConfiguration lc = resolveLaunchConfiguration(asg);+ if (lc != null) {+ return new LaunchSource(+ lc.getLaunchConfigurationName(),+ lc.getImageId(),+ lc.getInstanceType(),+ lc.getKeyName(),+ lc.getSecurityGroups(),+ List.of(),+ lc.getUserData(),+ lc.getIamInstanceProfile(),+ null,+ null,+ null);+ }++ LaunchTemplate launchTemplate = resolveLaunchTemplate(asg);+ if (launchTemplate != null) {+ LaunchTemplate version = ec2Service.describeLaunchTemplateVersions(+ asg.getRegion(),+ launchTemplate.getLaunchTemplateId(),+ null,+ asg.getLaunchTemplateVersion() == null ? List.of() : List.of(asg.getLaunchTemplateVersion()))+ .getFirst();+ String resolvedVersion = version.getLatestVersionNumber() != null+ ? version.getLatestVersionNumber()+ : asg.getLaunchTemplateVersion();+ return new LaunchSource(+ null,+ version.getImageId(),+ version.getInstanceType(),+ version.getKeyName(),+ version.getSecurityGroupIds(),+ List.of(),+ version.getUserData(),+ null,+ asg.getLaunchTemplateId(),+ asg.getLaunchTemplateName(),+ resolvedVersion);+ }++ return null;+ }+private LaunchConfiguration resolveLaunchConfiguration(AutoScalingGroup asg) {String lcName = asg.getLaunchConfigurationName();if (lcName == null || lcName.isBlank()) {@@ -209,6 +377,33 @@ public class AutoScalingReconciler {return lcs.isEmpty() ? null : lcs.get(0);}+ private LaunchTemplate resolveLaunchTemplate(AutoScalingGroup asg) {+ String ltId = asg.getLaunchTemplateId();+ String ltName = asg.getLaunchTemplateName();+ if ((ltId == null || ltId.isBlank()) && (ltName == null || ltName.isBlank())) {+ return null;+ }+ List<LaunchTemplate> launchTemplates = ec2Service.describeLaunchTemplates(+ asg.getRegion(),+ ltId == null || ltId.isBlank() ? List.of() : List.of(ltId),+ ltName == null || ltName.isBlank() ? List.of() : List.of(ltName),+ Map.of());+ return launchTemplates.isEmpty() ? null : launchTemplates.get(0);+ }++ private record LaunchSource(+ String launchConfigurationName,+ String imageId,+ String instanceType,+ String keyName,+ List<String> securityGroupIds,+ List<io.github.hectorvent.floci.services.ec2.model.Tag> instanceTags,+ String userData,+ String iamInstanceProfile,+ String launchTemplateId,+ String launchTemplateName,+ String launchTemplateVersion) {}+// Override for describeAutoScalingGroups with null region (all regions)// The service only filters by region when non-null; null means all.// We add a bridge here to avoid changing the service signature.diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.javaindex b155756e69..2eb3a9b15e 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingService.java@@ -1,9 +1,14 @@package io.github.hectorvent.floci.services.autoscaling;+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.autoscaling.model.*;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import jakarta.annotation.PostConstruct;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -18,12 +23,38 @@ public class AutoScalingService {@InjectRegionResolver regionResolver;+ @Inject+ StorageFactory storageFactory;++ @Inject+ Ec2Service ec2Service;+// region :: name → resource- private final Map<String, LaunchConfiguration> launchConfigs = new ConcurrentHashMap<>();- private final Map<String, AutoScalingGroup> groups = new ConcurrentHashMap<>();- private final Map<String, LifecycleHook> hooks = new ConcurrentHashMap<>();- private final Map<String, ScalingPolicy> policies = new ConcurrentHashMap<>();- private final Map<String, ScalingActivity> activities = new ConcurrentHashMap<>();+ private Map<String, LaunchConfiguration> launchConfigs = new ConcurrentHashMap<>();+ private Map<String, AutoScalingGroup> groups = new ConcurrentHashMap<>();+ private Map<String, LifecycleHook> hooks = new ConcurrentHashMap<>();+ private Map<String, ScalingPolicy> policies = new ConcurrentHashMap<>();+ private Map<String, ScalingActivity> activities = new ConcurrentHashMap<>();+ private Map<String, InstanceRefresh> instanceRefreshes = new ConcurrentHashMap<>();++ @PostConstruct+ void initializeStorage()+ {+ if (storageFactory == null) {+ return;+ }+ this.launchConfigs = storageBacked("autoscaling-launch-configurations.json", new TypeReference<Map<String, LaunchConfiguration>>() {});+ this.groups = storageBacked("autoscaling-groups.json", new TypeReference<Map<String, AutoScalingGroup>>() {});+ this.hooks = storageBacked("autoscaling-lifecycle-hooks.json", new TypeReference<Map<String, LifecycleHook>>() {});+ this.policies = storageBacked("autoscaling-policies.json", new TypeReference<Map<String, ScalingPolicy>>() {});+ this.activities = storageBacked("autoscaling-activities.json", new TypeReference<Map<String, ScalingActivity>>() {});+ this.instanceRefreshes = storageBacked("autoscaling-instance-refreshes.json", new TypeReference<Map<String, InstanceRefresh>>() {});+ }++ private <V> Map<String, V> storageBacked(String fileName, TypeReference<Map<String, V>> typeReference)+ {+ return new StorageBackedMap<>(storageFactory.create("autoscaling", fileName, typeReference));+ }// ── Launch Configurations ──────────────────────────────────────────────────@@ -78,9 +109,11 @@ public class AutoScalingService {public AutoScalingGroup createAutoScalingGroup(String region, String name,String launchConfigName,- String launchTemplateName, String launchTemplateVersion,+ String launchTemplateId, String launchTemplateName,+ String launchTemplateVersion,int minSize, int maxSize, int desiredCapacity,int defaultCooldown, List<String> availabilityZones,+ List<String> subnetIds,List<String> targetGroupArns, List<String> lbNames,String healthCheckType, int healthCheckGracePeriod,List<String> terminationPolicies,@@ -90,7 +123,7 @@ public class AutoScalingService {throw new AwsException("AlreadyExists","Auto Scaling group '" + name + "' already exists.", 400);}- if (launchConfigName == null && launchTemplateName == null) {+ if (launchConfigName == null && launchTemplateId == null && launchTemplateName == null) {throw new AwsException("ValidationError","Either LaunchConfigurationName or LaunchTemplate must be specified.", 400);}@@ -101,6 +134,7 @@ public class AutoScalingService {AwsArnUtils.Arn.of("autoscaling", region, regionResolver.getAccountId(),"autoScalingGroup:" + name).toString());asg.setLaunchConfigurationName(launchConfigName);+ asg.setLaunchTemplateId(launchTemplateId);asg.setLaunchTemplateName(launchTemplateName);asg.setLaunchTemplateVersion(launchTemplateVersion);asg.setMinSize(minSize);@@ -108,6 +142,7 @@ public class AutoScalingService {asg.setDesiredCapacity(desiredCapacity);asg.setDefaultCooldown(defaultCooldown > 0 ? defaultCooldown : 300);asg.setAvailabilityZones(availabilityZones != null ? new ArrayList<>(availabilityZones) : new ArrayList<>());+ asg.setSubnetIds(subnetIds != null ? new ArrayList<>(subnetIds) : new ArrayList<>());asg.setTargetGroupARNs(targetGroupArns != null ? new ArrayList<>(targetGroupArns) : new ArrayList<>());asg.setLoadBalancerNames(lbNames != null ? new ArrayList<>(lbNames) : new ArrayList<>());asg.setHealthCheckType(healthCheckType != null ? healthCheckType : "EC2");@@ -124,16 +159,19 @@ public class AutoScalingService {public void updateAutoScalingGroup(String region, String name,String launchConfigName,- String launchTemplateName, String launchTemplateVersion,+ String launchTemplateId, String launchTemplateName,+ String launchTemplateVersion,Integer minSize, Integer maxSize, Integer desiredCapacity,Integer defaultCooldown, List<String> availabilityZones,+ List<String> subnetIds,String healthCheckType, Integer healthCheckGracePeriod,List<String> terminationPolicies) {AutoScalingGroup asg = requireGroup(region, name);if (launchConfigName != null) {asg.setLaunchConfigurationName(launchConfigName);}- if (launchTemplateName != null) {+ if (launchTemplateId != null || launchTemplateName != null) {+ asg.setLaunchTemplateId(launchTemplateId);asg.setLaunchTemplateName(launchTemplateName);asg.setLaunchTemplateVersion(launchTemplateVersion);}@@ -142,9 +180,11 @@ public class AutoScalingService {if (desiredCapacity != null) { asg.setDesiredCapacity(desiredCapacity); }if (defaultCooldown != null) { asg.setDefaultCooldown(defaultCooldown); }if (availabilityZones != null) { asg.setAvailabilityZones(new ArrayList<>(availabilityZones)); }+ if (subnetIds != null) { asg.setSubnetIds(new ArrayList<>(subnetIds)); }if (healthCheckType != null) { asg.setHealthCheckType(healthCheckType); }if (healthCheckGracePeriod != null) { asg.setHealthCheckGracePeriod(healthCheckGracePeriod); }if (terminationPolicies != null) { asg.setTerminationPolicies(new ArrayList<>(terminationPolicies)); }+ groups.put(asgKey(region, name), asg);}public void deleteAutoScalingGroup(String region, String name, boolean forceDelete) {@@ -157,10 +197,24 @@ public class AutoScalingService {"Auto Scaling group '" + name + "' has " + active.size()+ " instance(s). Set ForceDelete=true to delete anyway.", 400);}+ if (forceDelete && ec2Service != null && !active.isEmpty()) {+ active.stream()+ .map(AsgInstance::getInstanceId)+ .filter(Objects::nonNull)+ .forEach(instanceId -> {+ try {+ ec2Service.terminateInstances(region, List.of(instanceId));+ }+ catch (AwsException ignored) {+ // ForceDelete should remove stale ASG membership even if EC2 no longer has the instance.+ }+ });+ }groups.remove(asgKey(region, name));// clean up associated hooks and policieshooks.entrySet().removeIf(e -> e.getValue().getAutoScalingGroupName().equals(name));policies.entrySet().removeIf(e -> e.getValue().getAutoScalingGroupName().equals(name));+ instanceRefreshes.entrySet().removeIf(e -> e.getValue().getAutoScalingGroupName().equals(name));}public List<AutoScalingGroup> describeAutoScalingGroups(String region, List<String> names) {@@ -175,6 +229,10 @@ public class AutoScalingService {.collect(Collectors.toList());}+ public void saveAutoScalingGroup(AutoScalingGroup asg) {+ groups.put(asgKey(asg.getRegion(), asg.getAutoScalingGroupName()), asg);+ }+public void setDesiredCapacity(String region, String name, int desiredCapacity) {AutoScalingGroup asg = requireGroup(region, name);if (desiredCapacity < asg.getMinSize() || desiredCapacity > asg.getMaxSize()) {@@ -183,6 +241,27 @@ public class AutoScalingService {+ asg.getMinSize() + " and MaxSize=" + asg.getMaxSize() + ".", 400);}asg.setDesiredCapacity(desiredCapacity);+ groups.put(asgKey(region, name), asg);+ }++ public void createOrUpdateTags(String region, String resourceId, String resourceType, Map<String, String> tags) {+ AutoScalingGroup asg = requireTaggableGroup(region, resourceId, resourceType);+ asg.getTags().putAll(tags);+ groups.put(asgKey(region, asg.getAutoScalingGroupName()), asg);+ }++ public void deleteTags(String region, String resourceId, String resourceType, List<String> tagKeys) {+ AutoScalingGroup asg = requireTaggableGroup(region, resourceId, resourceType);+ tagKeys.forEach(asg.getTags()::remove);+ groups.put(asgKey(region, asg.getAutoScalingGroupName()), asg);+ }++ private AutoScalingGroup requireTaggableGroup(String region, String resourceId, String resourceType) {+ if (!"auto-scaling-group".equals(resourceType)) {+ throw new AwsException("ValidationError",+ "Unsupported tag resource type '" + resourceType + "'.", 400);+ }+ return requireGroup(region, resourceId);}// ── Instance management ────────────────────────────────────────────────────@@ -209,11 +288,15 @@ public class AutoScalingService {inst.setAvailabilityZone(asg.getAvailabilityZones().isEmpty() ? region + "a" : asg.getAvailabilityZones().get(0));inst.setLaunchConfigurationName(asg.getLaunchConfigurationName());+ inst.setLaunchTemplateId(asg.getLaunchTemplateId());+ inst.setLaunchTemplateName(asg.getLaunchTemplateName());+ inst.setLaunchTemplateVersion(asg.getLaunchTemplateVersion());asg.getInstances().add(inst);}if (asg.getInstances().size() > asg.getDesiredCapacity()) {asg.setDesiredCapacity(asg.getInstances().size());}+ groups.put(asgKey(region, name), asg);}public void detachInstances(String region, String name, List<String> instanceIds,@@ -224,6 +307,7 @@ public class AutoScalingService {int newDesired = Math.max(asg.getMinSize(), asg.getDesiredCapacity() - instanceIds.size());asg.setDesiredCapacity(newDesired);}+ groups.put(asgKey(region, name), asg);}public void terminateInstanceInAutoScalingGroup(String region, String instanceId,@@ -242,6 +326,100 @@ public class AutoScalingService {int newDesired = Math.max(asg.getMinSize(), asg.getDesiredCapacity() - 1);asg.setDesiredCapacity(newDesired);}+ groups.put(asgKey(region, asg.getAutoScalingGroupName()), asg);+ }++ // ── Instance refreshes ────────────────────────────────────────────────────++ public InstanceRefresh startInstanceRefresh(String region, String asgName, InstanceRefresh requestedRefresh) {+ AutoScalingGroup asg = requireGroup(region, asgName);+ boolean activeRefresh = instanceRefreshes.values().stream()+ .filter(r -> region.equals(r.getRegion()))+ .filter(r -> asgName.equals(r.getAutoScalingGroupName()))+ .anyMatch(r -> isActiveRefreshStatus(r.getStatus()));+ if (activeRefresh) {+ throw new AwsException("InstanceRefreshInProgress",+ "An active instance refresh already exists for Auto Scaling group '" + asgName + "'.", 400);+ }++ Instant now = Instant.now();+ InstanceRefresh refresh = new InstanceRefresh();+ refresh.setInstanceRefreshId(UUID.randomUUID().toString());+ refresh.setAutoScalingGroupName(asgName);+ refresh.setStrategy(normalizeRefreshStrategy(requestedRefresh.getStrategy()));+ refresh.setStartTime(now);+ refresh.setRegion(region);+ copyDesiredConfiguration(requestedRefresh, refresh);+ copyPreferences(requestedRefresh, refresh);++ applyDesiredConfiguration(asg, refresh);+ List<String> instanceIds = markInstancesForRefresh(asg, refresh);+ if (instanceIds.isEmpty()) {+ refresh.setStatus("Successful");+ refresh.setStatusReason("Instance refresh completed.");+ refresh.setPercentageComplete(100);+ refresh.setInstancesToUpdate(0);+ refresh.setEndTime(now);+ } else {+ refresh.setStatus("InProgress");+ refresh.setStatusReason("Instance refresh in progress.");+ refresh.setPercentageComplete(0);+ refresh.setInstancesToUpdate(instanceIds.size());+ }+ instanceRefreshes.put(instanceRefreshKey(region, asgName, refresh.getInstanceRefreshId()), refresh);+ groups.put(asgKey(region, asgName), asg);+ if (!instanceIds.isEmpty()) {+ recordActivity(region, asgName,+ "Marked EC2 instance(s) for refresh: " + instanceIds,+ "At " + now + " an instance refresh selected active instances for replacement.",+ "Successful");+ }+ recordActivity(region, asgName,+ "Started instance refresh " + refresh.getInstanceRefreshId() + ".",+ "At " + now + " an instance refresh was started.",+ "Successful");+ return refresh;+ }++ public void completeInstanceRefreshIfSettled(String region, String asgName) {+ AutoScalingGroup asg = requireGroup(region, asgName);+ List<InstanceRefresh> activeRefreshes = instanceRefreshes.values().stream()+ .filter(r -> region.equals(r.getRegion()))+ .filter(r -> asgName.equals(r.getAutoScalingGroupName()))+ .filter(r -> isActiveRefreshStatus(r.getStatus()))+ .collect(Collectors.toList());+ for (InstanceRefresh refresh : activeRefreshes) {+ int remaining = remainingInstancesToUpdate(asg);+ refresh.setInstancesToUpdate(remaining);+ refresh.setPercentageComplete(remaining == 0 ? 100 : 0);+ if (remaining == 0) {+ refresh.setStatus("Successful");+ refresh.setStatusReason("Instance refresh completed.");+ refresh.setEndTime(Instant.now());+ }+ instanceRefreshes.put(instanceRefreshKey(region, asgName, refresh.getInstanceRefreshId()), refresh);+ }+ }++ public InstanceRefreshPage describeInstanceRefreshes(String region, String asgName, List<String> refreshIds,+ Integer maxRecords, String nextToken) {+ requireGroup(region, asgName);+ int offset = parseNextToken(nextToken);+ int limit = maxRecords != null ? Math.min(Math.max(maxRecords, 1), 100) : 50;+ Set<String> requestedIds = refreshIds != null && !refreshIds.isEmpty()+ ? new HashSet<>(refreshIds) : null;+ List<InstanceRefresh> matches = instanceRefreshes.values().stream()+ .filter(r -> region.equals(r.getRegion()))+ .filter(r -> asgName.equals(r.getAutoScalingGroupName()))+ .filter(r -> requestedIds == null || requestedIds.contains(r.getInstanceRefreshId()))+ .sorted(Comparator.comparing(InstanceRefresh::getStartTime).reversed())+ .collect(Collectors.toList());+ if (offset > matches.size()) {+ throw new AwsException("InvalidNextToken", "The NextToken value is not valid.", 400);+ }+ int end = Math.min(offset + limit, matches.size());+ String followingToken = end < matches.size() ? String.valueOf(end) : null;+ return new InstanceRefreshPage(matches.subList(offset, end), followingToken);}// ── Load balancer attachment ───────────────────────────────────────────────@@ -253,11 +431,13 @@ public class AutoScalingService {asg.getTargetGroupARNs().add(arn);}}+ groups.put(asgKey(region, name), asg);}public void detachLoadBalancerTargetGroups(String region, String name, List<String> tgArns) {AutoScalingGroup asg = requireGroup(region, name);asg.getTargetGroupARNs().removeAll(tgArns);+ groups.put(asgKey(region, name), asg);}public List<String> describeLoadBalancerTargetGroups(String region, String name) {@@ -271,10 +451,13 @@ public class AutoScalingService {asg.getLoadBalancerNames().add(lb);}}+ groups.put(asgKey(region, name), asg);}public void detachLoadBalancers(String region, String name, List<String> lbNames) {- requireGroup(region, name).getLoadBalancerNames().removeAll(lbNames);+ AutoScalingGroup asg = requireGroup(region, name);+ asg.getLoadBalancerNames().removeAll(lbNames);+ groups.put(asgKey(region, name), asg);}// ── Lifecycle hooks ────────────────────────────────────────────────────────@@ -294,6 +477,7 @@ public class AutoScalingService {hook.setNotificationMetadata(notificationMetadata);if (heartbeatTimeout != null) { hook.setHeartbeatTimeout(heartbeatTimeout); }if (defaultResult != null) { hook.setDefaultResult(defaultResult); }+ hooks.put(key, hook);}public void deleteLifecycleHook(String region, String asgName, String hookName) {@@ -335,6 +519,7 @@ public class AutoScalingService {policy.setScalingAdjustment(scalingAdjustment);policy.setCooldown(cooldown);policy.setRegion(region);+ policies.put(key, policy);return policy;}@@ -383,9 +568,12 @@ public class AutoScalingService {activity.setStatusCode(statusCode);activity.setStatusMessage(statusMessage);activity.setProgress(100);+ activities.put(activityId, activity);}}+ public record InstanceRefreshPage(List<InstanceRefresh> instanceRefreshes, String nextToken) {}+// ── Internal helpers ───────────────────────────────────────────────────────AutoScalingGroup requireGroup(String region, String name) {@@ -412,4 +600,147 @@ public class AutoScalingService {private static String policyKey(String region, String asgName, String policyName) {return region + "::" + asgName + "::" + policyName;}++ private static String instanceRefreshKey(String region, String asgName, String refreshId) {+ return region + "::" + asgName + "::" + refreshId;+ }++ private static boolean isActiveRefreshStatus(String status) {+ return "Pending".equals(status)+ || "InProgress".equals(status)+ || "Cancelling".equals(status)+ || "RollbackInProgress".equals(status)+ || "Baking".equals(status);+ }++ private static String normalizeRefreshStrategy(String strategy) {+ if (strategy == null || strategy.isBlank()) {+ return "Rolling";+ }+ if (!"Rolling".equals(strategy) && !"ReplaceRootVolume".equals(strategy)) {+ throw new AwsException("ValidationError",+ "Unsupported instance refresh strategy '" + strategy + "'.", 400);+ }+ return strategy;+ }++ private static int parseNextToken(String nextToken) {+ if (nextToken == null || nextToken.isBlank()) {+ return 0;+ }+ try {+ int offset = Integer.parseInt(nextToken);+ if (offset < 0) {+ throw new NumberFormatException("negative");+ }+ return offset;+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidNextToken", "The NextToken value is not valid.", 400);+ }+ }++ private static void copyDesiredConfiguration(InstanceRefresh source, InstanceRefresh target) {+ target.setDesiredLaunchTemplateId(source.getDesiredLaunchTemplateId());+ target.setDesiredLaunchTemplateName(source.getDesiredLaunchTemplateName());+ target.setDesiredLaunchTemplateVersion(source.getDesiredLaunchTemplateVersion());+ }++ private static void copyPreferences(InstanceRefresh source, InstanceRefresh target) {+ target.setMinHealthyPercentage(source.getMinHealthyPercentage());+ target.setMaxHealthyPercentage(source.getMaxHealthyPercentage());+ target.setInstanceWarmup(source.getInstanceWarmup());+ target.setSkipMatching(source.getSkipMatching());+ target.setAutoRollback(source.getAutoRollback());+ target.setScaleInProtectedInstances(source.getScaleInProtectedInstances());+ target.setStandbyInstances(source.getStandbyInstances());+ target.setCheckpointDelay(source.getCheckpointDelay());+ target.setBakeTime(source.getBakeTime());+ target.setCheckpointPercentages(new ArrayList<>(source.getCheckpointPercentages()));+ }++ private static void applyDesiredConfiguration(AutoScalingGroup asg, InstanceRefresh refresh) {+ if (!refresh.hasDesiredConfiguration()) {+ return;+ }+ if (refresh.getDesiredLaunchTemplateId() != null || refresh.getDesiredLaunchTemplateName() != null) {+ asg.setLaunchTemplateId(refresh.getDesiredLaunchTemplateId());+ asg.setLaunchTemplateName(refresh.getDesiredLaunchTemplateName());+ asg.setLaunchConfigurationName(null);+ }+ if (refresh.getDesiredLaunchTemplateVersion() != null) {+ asg.setLaunchTemplateVersion(refresh.getDesiredLaunchTemplateVersion());+ }+ }++ private static List<String> markInstancesForRefresh(AutoScalingGroup asg, InstanceRefresh refresh) {+ boolean skipMatching = Boolean.TRUE.equals(refresh.getSkipMatching());+ List<String> instanceIds = new ArrayList<>();+ for (AsgInstance instance : asg.getInstances()) {+ if (!isRefreshCandidate(instance, asg, skipMatching)) {+ continue;+ }+ instance.setLifecycleState("Terminating");+ instanceIds.add(instance.getInstanceId());+ }+ return instanceIds;+ }++ private static boolean isRefreshCandidate(AsgInstance instance, AutoScalingGroup asg, boolean skipMatching) {+ String state = instance.getLifecycleState();+ if (!"Pending".equals(state) && !"InService".equals(state)) {+ return false;+ }+ if (!skipMatching) {+ return true;+ }+ if (isDynamicLaunchTemplateVersion(asg.getLaunchTemplateVersion())+ && (asg.getLaunchTemplateId() != null || asg.getLaunchTemplateName() != null)) {+ return true;+ }+ return !Objects.equals(instance.getLaunchConfigurationName(), asg.getLaunchConfigurationName())+ || !Objects.equals(instance.getLaunchTemplateId(), asg.getLaunchTemplateId())+ || !Objects.equals(instance.getLaunchTemplateName(), asg.getLaunchTemplateName())+ || !Objects.equals(instance.getLaunchTemplateVersion(), asg.getLaunchTemplateVersion());+ }++ private static int remainingInstancesToUpdate(AutoScalingGroup asg) {+ int remaining = 0;+ int matchingInService = 0;+ for (AsgInstance instance : asg.getInstances()) {+ String state = instance.getLifecycleState();+ if ("Terminating".equals(state) || "Pending".equals(state)) {+ remaining++;+ continue;+ }+ if ("InService".equals(state)) {+ if (matchesCurrentLaunchSource(instance, asg)) {+ matchingInService++;+ } else {+ remaining++;+ }+ }+ }+ remaining += Math.max(0, asg.getDesiredCapacity() - matchingInService);+ return remaining;+ }++ private static boolean matchesCurrentLaunchSource(AsgInstance instance, AutoScalingGroup asg) {+ if (isDynamicLaunchTemplateVersion(asg.getLaunchTemplateVersion())+ && Objects.equals(instance.getLaunchTemplateId(), asg.getLaunchTemplateId())+ && Objects.equals(instance.getLaunchTemplateName(), asg.getLaunchTemplateName())) {+ return true;+ }+ return Objects.equals(instance.getLaunchConfigurationName(), asg.getLaunchConfigurationName())+ && Objects.equals(instance.getLaunchTemplateId(), asg.getLaunchTemplateId())+ && Objects.equals(instance.getLaunchTemplateName(), asg.getLaunchTemplateName())+ && Objects.equals(instance.getLaunchTemplateVersion(), asg.getLaunchTemplateVersion());+ }++ private static boolean isLaunchTemplateVersionAlias(String version) {+ return "$Latest".equals(version) || "$Default".equals(version);+ }++ private static boolean isDynamicLaunchTemplateVersion(String version) {+ return version == null || version.isBlank() || isLaunchTemplateVersionAlias(version);+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgInstance.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgInstance.javaindex cb2e4850b3..f7c4ada60c 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgInstance.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgInstance.java@@ -12,6 +12,9 @@ public class AsgInstance {private String lifecycleState; // Pending | InService | Terminating | Terminated | Detachedprivate String healthStatus; // Healthy | Unhealthyprivate String launchConfigurationName;+ private String launchTemplateId;+ private String launchTemplateName;+ private String launchTemplateVersion;private String instanceType;private boolean protectedFromScaleIn;@@ -32,6 +35,15 @@ public class AsgInstance {public String getLaunchConfigurationName() { return launchConfigurationName; }public void setLaunchConfigurationName(String v) { this.launchConfigurationName = v; }+ public String getLaunchTemplateId() { return launchTemplateId; }+ public void setLaunchTemplateId(String v) { this.launchTemplateId = v; }++ public String getLaunchTemplateName() { return launchTemplateName; }+ public void setLaunchTemplateName(String v) { this.launchTemplateName = v; }++ public String getLaunchTemplateVersion() { return launchTemplateVersion; }+ public void setLaunchTemplateVersion(String v) { this.launchTemplateVersion = v; }+public String getInstanceType() { return instanceType; }public void setInstanceType(String v) { this.instanceType = v; }diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AutoScalingGroup.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AutoScalingGroup.javaindex 8115a8d2ed..0f718ffe49 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AutoScalingGroup.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AutoScalingGroup.java@@ -16,6 +16,7 @@ public class AutoScalingGroup {private String autoScalingGroupName;private String autoScalingGroupArn;private String launchConfigurationName;+ private String launchTemplateId;private String launchTemplateName;private String launchTemplateVersion;private int minSize;@@ -23,6 +24,7 @@ public class AutoScalingGroup {private int desiredCapacity;private int defaultCooldown = 300;private List<String> availabilityZones = new ArrayList<>();+ private List<String> subnetIds = new ArrayList<>();private List<String> loadBalancerNames = new ArrayList<>();private List<String> targetGroupARNs = new ArrayList<>();private String healthCheckType = "EC2";@@ -45,6 +47,9 @@ public class AutoScalingGroup {public String getLaunchConfigurationName() { return launchConfigurationName; }public void setLaunchConfigurationName(String v) { this.launchConfigurationName = v; }+ public String getLaunchTemplateId() { return launchTemplateId; }+ public void setLaunchTemplateId(String v) { this.launchTemplateId = v; }+public String getLaunchTemplateName() { return launchTemplateName; }public void setLaunchTemplateName(String v) { this.launchTemplateName = v; }@@ -66,6 +71,9 @@ public class AutoScalingGroup {public List<String> getAvailabilityZones() { return availabilityZones; }public void setAvailabilityZones(List<String> v) { this.availabilityZones = v; }+ public List<String> getSubnetIds() { return subnetIds; }+ public void setSubnetIds(List<String> v) { this.subnetIds = v; }+public List<String> getLoadBalancerNames() { return loadBalancerNames; }public void setLoadBalancerNames(List<String> v) { this.loadBalancerNames = v; }diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/InstanceRefresh.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/InstanceRefresh.javanew file mode 100644index 0000000000..0a95d164e1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/InstanceRefresh.java@@ -0,0 +1,131 @@+package io.github.hectorvent.floci.services.autoscaling.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class InstanceRefresh {++ private String instanceRefreshId;+ private String autoScalingGroupName;+ private String strategy = "Rolling";+ private String status;+ private String statusReason;+ private int percentageComplete;+ private int instancesToUpdate;+ private Instant startTime;+ private Instant endTime;+ private String region;++ private String desiredLaunchTemplateId;+ private String desiredLaunchTemplateName;+ private String desiredLaunchTemplateVersion;++ private Integer minHealthyPercentage;+ private Integer maxHealthyPercentage;+ private Integer instanceWarmup;+ private Boolean skipMatching;+ private Boolean autoRollback;+ private String scaleInProtectedInstances;+ private String standbyInstances;+ private Integer checkpointDelay;+ private Integer bakeTime;+ private List<Integer> checkpointPercentages = new ArrayList<>();++ public InstanceRefresh() {}++ public String getInstanceRefreshId() { return instanceRefreshId; }+ public void setInstanceRefreshId(String v) { this.instanceRefreshId = v; }++ public String getAutoScalingGroupName() { return autoScalingGroupName; }+ public void setAutoScalingGroupName(String v) { this.autoScalingGroupName = v; }++ public String getStrategy() { return strategy; }+ public void setStrategy(String v) { this.strategy = v; }++ public String getStatus() { return status; }+ public void setStatus(String v) { this.status = v; }++ public String getStatusReason() { return statusReason; }+ public void setStatusReason(String v) { this.statusReason = v; }++ public int getPercentageComplete() { return percentageComplete; }+ public void setPercentageComplete(int v) { this.percentageComplete = v; }++ public int getInstancesToUpdate() { return instancesToUpdate; }+ public void setInstancesToUpdate(int v) { this.instancesToUpdate = v; }++ public Instant getStartTime() { return startTime; }+ public void setStartTime(Instant v) { this.startTime = v; }++ public Instant getEndTime() { return endTime; }+ public void setEndTime(Instant v) { this.endTime = v; }++ public String getRegion() { return region; }+ public void setRegion(String v) { this.region = v; }++ public String getDesiredLaunchTemplateId() { return desiredLaunchTemplateId; }+ public void setDesiredLaunchTemplateId(String v) { this.desiredLaunchTemplateId = v; }++ public String getDesiredLaunchTemplateName() { return desiredLaunchTemplateName; }+ public void setDesiredLaunchTemplateName(String v) { this.desiredLaunchTemplateName = v; }++ public String getDesiredLaunchTemplateVersion() { return desiredLaunchTemplateVersion; }+ public void setDesiredLaunchTemplateVersion(String v) { this.desiredLaunchTemplateVersion = v; }++ public Integer getMinHealthyPercentage() { return minHealthyPercentage; }+ public void setMinHealthyPercentage(Integer v) { this.minHealthyPercentage = v; }++ public Integer getMaxHealthyPercentage() { return maxHealthyPercentage; }+ public void setMaxHealthyPercentage(Integer v) { this.maxHealthyPercentage = v; }++ public Integer getInstanceWarmup() { return instanceWarmup; }+ public void setInstanceWarmup(Integer v) { this.instanceWarmup = v; }++ public Boolean getSkipMatching() { return skipMatching; }+ public void setSkipMatching(Boolean v) { this.skipMatching = v; }++ public Boolean getAutoRollback() { return autoRollback; }+ public void setAutoRollback(Boolean v) { this.autoRollback = v; }++ public String getScaleInProtectedInstances() { return scaleInProtectedInstances; }+ public void setScaleInProtectedInstances(String v) { this.scaleInProtectedInstances = v; }++ public String getStandbyInstances() { return standbyInstances; }+ public void setStandbyInstances(String v) { this.standbyInstances = v; }++ public Integer getCheckpointDelay() { return checkpointDelay; }+ public void setCheckpointDelay(Integer v) { this.checkpointDelay = v; }++ public Integer getBakeTime() { return bakeTime; }+ public void setBakeTime(Integer v) { this.bakeTime = v; }++ public List<Integer> getCheckpointPercentages() { return checkpointPercentages; }+ public void setCheckpointPercentages(List<Integer> v) {+ this.checkpointPercentages = v != null ? v : new ArrayList<>();+ }++ public boolean hasDesiredConfiguration() {+ return desiredLaunchTemplateId != null+ || desiredLaunchTemplateName != null+ || desiredLaunchTemplateVersion != null;+ }++ public boolean hasPreferences() {+ return minHealthyPercentage != null+ || maxHealthyPercentage != null+ || instanceWarmup != null+ || skipMatching != null+ || autoRollback != null+ || scaleInProtectedInstances != null+ || standbyInstances != null+ || checkpointDelay != null+ || bakeTime != null+ || !checkpointPercentages.isEmpty();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.javaindex ec5cb01af5..31d4a8b11e 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java@@ -776,12 +776,13 @@ public class CloudFormationResourceProvisioner {}var asg = autoScalingService.createAutoScalingGroup(region, name,- blankToNull(launchConfigName), blankToNull(launchTemplateName), blankToNull(launchTemplateVersion),+ blankToNull(launchConfigName), null, blankToNull(launchTemplateName), blankToNull(launchTemplateVersion),parseIntProp(props, "MinSize", engine, 0),parseIntProp(props, "MaxSize", engine, 0),parseIntProp(props, "DesiredCapacity", engine, 0),parseIntProp(props, "Cooldown", engine, 0),resolveStringList(props, "AvailabilityZones", engine),+ resolveStringList(props, "VPCZoneIdentifier", engine),resolveStringList(props, "TargetGroupARNs", engine),resolveStringList(props, "LoadBalancerNames", engine),resolveOptional(props, "HealthCheckType", engine),diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.javaindex 307b2fb058..4cf1566a88 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.java@@ -25,11 +25,17 @@ import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.nio.charset.StandardCharsets;+import java.util.ArrayList;import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.Optional;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;+import java.util.regex.Matcher;+import java.util.regex.Pattern;/*** Manages Docker container lifecycle for EC2 instances.@@ -40,6 +46,10 @@ import java.util.concurrent.TimeUnit;public class Ec2ContainerManager {private static final Logger LOG = Logger.getLogger(Ec2ContainerManager.class);+ private static final String USER_DATA_SCRIPT_PATH = "/tmp/user-data.sh";+ private static final Pattern MIME_BOUNDARY = Pattern.compile("(?im)^content-type:\\s*multipart/[^;]+;\\s*boundary=\"?([^\";\\n\\r]+)\"?.*$");+ static int containerBridgeIpAttempts = 30;+ static long containerBridgeIpPollMillis = 500;private final ContainerBuilder containerBuilder;private final ContainerLifecycleManager lifecycleManager;@@ -106,18 +116,23 @@ public class Ec2ContainerManager {String flociHost = dockerHostResolver.resolve();int imdsPort = config.services().ec2().imdsPort();String imdsEndpoint = "http://" + flociHost + ":" + imdsPort;+ String serviceEndpoint = "http://" + flociHost + ":4566";// Build container spec — use tail -f /dev/null to keep container alive// regardless of the base image's default CMD.ContainerSpec spec = containerBuilder.newContainer(dockerImage).withName(containerName)- .withEnv("AWS_EC2_METADATA_SERVICE_ENDPOINT", imdsEndpoint).withEmbeddedDns()+ .withDockerNetwork(Optional.empty())+ .withEnv(localAwsEnvironment(region, serviceEndpoint, imdsEndpoint)).withEnv("AWS_EC2_INSTANCE_ID", instanceId)- .withEnv("AWS_DEFAULT_REGION", region).withPortBinding(22, sshHostPort).withHostDockerInternalOnLinux().withLogRotation()+ // EC2 instances expose IMDS on 169.254.169.254. Floci+ // needs network administration privileges in the local+ // container to attach that link-local address.+ .withPrivileged(true).withCmd(List.of("tail", "-f", "/dev/null")).build();@@ -143,17 +158,33 @@ public class Ec2ContainerManager {return;}- // Discover the container's bridge IP for IMDS registration- String containerIp = getContainerBridgeIp(containerId);+ // Discover the container's bridge IP for IMDS registration.+ // Docker can report the container as running before network+ // settings are populated; wait here so IMDS is registered+ // before link-local metadata validation and UserData run.+ String containerIp = waitForContainerBridgeIp(containerId, instanceId);if (containerIp != null && !containerIp.isBlank()) {instance.setContainerBridgeIp(containerIp);+ exposeReachablePrivateAddress(instance, containerIp);metadataServer.registerContainer(containerIp, instanceId, instance);}+ else {+ LOG.warnv("EC2 instance {0} container {1} did not receive a usable bridge IP for IMDS",+ instanceId, containerId);+ instance.setState(InstanceState.terminated());+ return;+ }++ configureLinkLocalMetadataEndpoint(containerId, instanceId, flociHost, imdsPort);// Set public-facing addressesinstance.setPublicIpAddress("127.0.0.1");instance.setPublicDnsName("localhost");+ instance.setState(InstanceState.running());+ LOG.infov("EC2 instance {0} running in container {1} (SSH host port {2})",+ instanceId, containerId, String.valueOf(sshHostPort));+// Inject SSH public keyif (publicKey != null && !publicKey.isBlank()) {injectSshKey(containerId, publicKey);@@ -166,10 +197,6 @@ public class Ec2ContainerManager {executeUserData(containerId, instanceId, userData, region);}- instance.setState(InstanceState.running());- LOG.infov("EC2 instance {0} running in container {1} (SSH host port {2})",- instanceId, containerId, String.valueOf(sshHostPort));-} catch (InterruptedException e) {Thread.currentThread().interrupt();instance.setState(InstanceState.terminated());@@ -224,6 +251,13 @@ public class Ec2ContainerManager {Thread.sleep(500);}}+ String instanceId = instance.getInstanceId();+ String containerIp = waitForContainerBridgeIp(containerId, instanceId);+ if (containerIp != null && !containerIp.isBlank()) {+ instance.setContainerBridgeIp(containerIp);+ exposeReachablePrivateAddress(instance, containerIp);+ metadataServer.registerContainer(containerIp, instanceId, instance);+ }} catch (InterruptedException e) {Thread.currentThread().interrupt();} catch (Exception e) {@@ -237,6 +271,51 @@ public class Ec2ContainerManager {return containerId != null && !containerId.isBlank() && lifecycleManager.isContainerRunning(containerId);}+ boolean restoreMetadataRegistration(Instance instance) {+ if (instance == null || instance.getDockerContainerId() == null) {+ return false;+ }+ String containerId = instance.getDockerContainerId();+ if (!lifecycleManager.isContainerRunning(containerId)) {+ return false;+ }++ String containerIp = getContainerBridgeIp(containerId);+ if (containerIp == null || containerIp.isBlank()) {+ containerIp = instance.getContainerBridgeIp();+ }+ if (containerIp == null || containerIp.isBlank()) {+ LOG.warnv("Could not restore IMDS registration for EC2 instance {0}: no container IP",+ instance.getInstanceId());+ return false;+ }++ String previousContainerIp = instance.getContainerBridgeIp();+ if (previousContainerIp != null && !previousContainerIp.isBlank() && !previousContainerIp.equals(containerIp)) {+ metadataServer.unregisterContainer(previousContainerIp, instance);+ }+ instance.setContainerBridgeIp(containerIp);+ exposeReachablePrivateAddress(instance, containerIp);+ metadataServer.registerContainer(containerIp, instance.getInstanceId(), instance);+ return true;+ }++ static void exposeReachablePrivateAddress(Instance instance, String privateIp) {+ if (instance == null || privateIp == null || privateIp.isBlank()) {+ return;+ }++ String privateDnsName = "ip-" + privateIp.replace('.', '-') + ".ec2.internal";+ instance.setPrivateIpAddress(privateIp);+ instance.setPrivateDnsName(privateDnsName);+ if (instance.getNetworkInterfaces() != null) {+ instance.getNetworkInterfaces().forEach(networkInterface -> {+ networkInterface.setPrivateIpAddress(privateIp);+ networkInterface.setPrivateDnsName(privateDnsName);+ });+ }+ }+/*** Terminates an instance: forcefully removes the container.* Updates state through shutting-down → terminated.@@ -266,7 +345,7 @@ public class Ec2ContainerManager {if (sshHostPort > 0) {portAllocator.release(sshHostPort);}- metadataServer.unregisterContainer(containerIp);+ metadataServer.unregisterContainer(containerIp, instance);instance.setState(InstanceState.terminated());instance.setTerminatedAt(System.currentTimeMillis());});@@ -290,6 +369,11 @@ public class Ec2ContainerManager {});}+ public boolean isContainerRunning(Instance instance) {+ String containerId = instance.getDockerContainerId();+ return containerId != null && lifecycleManager.isContainerRunning(containerId);+ }+private void injectSshKey(String containerId, String publicKey) {try {// Ensure .ssh directory exists with correct permissions@@ -333,52 +417,205 @@ public class Ec2ContainerManager {private void executeUserData(String containerId, String instanceId, String userData, String region) {try {- byte[] script = userData.getBytes(StandardCharsets.UTF_8);- byte[] tar = buildSingleFileTar("user-data.sh", script, 0755);- dockerClient.copyArchiveToContainerCmd(containerId)- .withRemotePath("/tmp")- .withTarInputStream(new ByteArrayInputStream(tar))- .exec();+ List<String> shellScripts = userDataShellScripts(userData);+ if (shellScripts.isEmpty()) {+ LOG.infov("UserData for EC2 instance {0} did not contain executable shellscript parts", instanceId);+ return;+ }- String logGroup = "/aws/ec2/" + instanceId;- String logStream = logStreamer.generateLogStreamName("user-data");-- // Execute the script and stream output to CloudWatch- String execId = dockerClient.execCreateCmd(containerId)- .withCmd("sh", "/tmp/user-data.sh")- .withAttachStdout(true)- .withAttachStderr(true)- .exec()- .getId();-- ByteArrayOutputStream output = new ByteArrayOutputStream();- CountDownLatch latch = new CountDownLatch(1);-- dockerClient.execStartCmd(execId).exec(new ResultCallback.Adapter<Frame>() {- @Override- public void onNext(Frame frame) {- if (frame.getPayload() != null) {- try { output.write(frame.getPayload()); } catch (IOException ignored) {}- }+ for (int i = 0; i < shellScripts.size(); i++) {+ executeUserDataShellScript(containerId, instanceId, shellScripts.get(i), i + 1, shellScripts.size());+ }+ } catch (Exception e) {+ LOG.warnv("UserData execution failed for EC2 instance {0}: {1}", instanceId, e.getMessage());+ }+ }++ private void executeUserDataShellScript(String containerId, String instanceId, String scriptContent, int partNumber, int partCount) throws Exception {+ byte[] script = scriptContent.getBytes(StandardCharsets.UTF_8);+ byte[] tar = buildSingleFileTar("user-data.sh", script, 0755);+ dockerClient.copyArchiveToContainerCmd(containerId)+ .withRemotePath("/tmp")+ .withTarInputStream(new ByteArrayInputStream(tar))+ .exec();++ // Execute the script directly so Docker honors its shebang, matching cloud-init shellscript behavior.+ String execId = dockerClient.execCreateCmd(containerId)+ .withCmd(userDataExecutionCommand())+ .withAttachStdout(true)+ .withAttachStderr(true)+ .exec()+ .getId();++ ByteArrayOutputStream output = new ByteArrayOutputStream();+ CountDownLatch latch = new CountDownLatch(1);++ dockerClient.execStartCmd(execId).exec(new ResultCallback.Adapter<Frame>() {+ @Override+ public void onNext(Frame frame) {+ if (frame.getPayload() != null) {+ try { output.write(frame.getPayload()); } catch (IOException ignored) {}}- @Override- public void onComplete() { latch.countDown(); }- @Override- public void onError(Throwable t) { latch.countDown(); }- });+ }+ @Override+ public void onComplete() { latch.countDown(); }+ @Override+ public void onError(Throwable t) { latch.countDown(); }+ });++ boolean completed = latch.await(30, TimeUnit.MINUTES);+ if (!completed) {+ LOG.warnv("UserData shellscript part {0}/{1} timed out for EC2 instance {2}", partNumber, partCount, instanceId);+ return;+ }++ Long exitCode = dockerClient.inspectExecCmd(execId).exec().getExitCodeLong();+ if (exitCode != null && exitCode != 0) {+ LOG.warnv("UserData shellscript part {0}/{1} failed for EC2 instance {2} with exit code {3}: {4}",+ partNumber, partCount, instanceId, exitCode, summarizeUserDataOutput(output));+ return;+ }++ LOG.infov("UserData shellscript part {0}/{1} completed for EC2 instance {2}: {3}",+ partNumber, partCount, instanceId, summarizeUserDataOutput(output));+ }++ static List<String> userDataShellScripts(String userData) {+ if (userData == null || userData.isBlank()) {+ return List.of();+ }++ String normalized = userData.replace("\r\n", "\n").replace('\r', '\n');+ String trimmed = normalized.stripLeading();+ if (trimmed.startsWith("#!")) {+ return List.of(normalized);+ }++ Matcher matcher = MIME_BOUNDARY.matcher(normalized);+ if (!matcher.find()) {+ return List.of();+ }++ String boundary = matcher.group(1).trim();+ if (boundary.isEmpty()) {+ return List.of();+ }++ List<String> scripts = new ArrayList<>();+ String marker = "--" + boundary;+ for (String segment : normalized.split(Pattern.quote(marker))) {+ String part = segment.stripLeading();+ if (part.isBlank() || part.startsWith("--")) {+ continue;+ }+ int headerEnd = part.indexOf("\n\n");+ if (headerEnd < 0) {+ continue;+ }+ String headers = part.substring(0, headerEnd);+ String body = part.substring(headerEnd + 2);+ if (hasShellscriptContentType(headers)) {+ scripts.add(body.stripTrailing() + "\n");+ }+ }+ return List.copyOf(scripts);+ }- boolean completed = latch.await(30, TimeUnit.MINUTES);- if (!completed) {- LOG.warnv("UserData execution timed out for EC2 instance {0}", instanceId);+ private static boolean hasShellscriptContentType(String headers) {+ for (String line : headers.split("\n")) {+ String lower = line.toLowerCase(Locale.ROOT).strip();+ if (lower.startsWith("content-type:") && lower.contains("text/x-shellscript")) {+ return true;}+ }+ return false;+ }++ static String[] userDataExecutionCommand() {+ return new String[]{USER_DATA_SCRIPT_PATH};+ }++ static String[] metadataProxyInstallCommand() {+ return new String[]{"sh", "-c", String.join("\n",+ "set -eu",+ "if command -v ip >/dev/null 2>&1 && command -v socat >/dev/null 2>&1 && command -v curl >/dev/null 2>&1; then exit 0; fi",+ "if command -v apt-get >/dev/null 2>&1; then",+ " apt-get update -qq >/dev/null",+ " DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends iproute2 socat curl ca-certificates >/dev/null",+ "elif command -v dnf >/dev/null 2>&1; then",+ " dnf install -y iproute socat curl ca-certificates >/dev/null",+ "elif command -v apk >/dev/null 2>&1; then",+ " apk add --no-cache iproute2 socat curl ca-certificates >/dev/null",+ "else",+ " echo 'No supported package manager found for IMDS proxy dependencies' >&2",+ " exit 1",+ "fi")};+ }- LOG.infov("UserData execution completed for EC2 instance {0}", instanceId);+ static String[] metadataProxyStartCommand(String flociHost, int imdsPort) {+ return new String[]{"sh", "-c", String.join("\n",+ "set -eu",+ "ip addr show dev lo | grep -q '169.254.169.254/32' || ip addr add 169.254.169.254/32 dev lo",+ "if [ -f /tmp/floci-imds-proxy.pid ] && kill -0 \"$(cat /tmp/floci-imds-proxy.pid)\" 2>/dev/null; then",+ " exit 0",+ "fi",+ "nohup socat TCP-LISTEN:80,bind=169.254.169.254,fork,reuseaddr TCP:" + flociHost + ":" + imdsPort + " >/tmp/floci-imds-proxy.log 2>&1 &",+ "echo $! > /tmp/floci-imds-proxy.pid",+ "for i in 1 2 3 4 5 6 7 8 9 10 11 12; do",+ " curl -fsS --max-time 1 http://169.254.169.254/latest/meta-data/instance-id >/dev/null && exit 0",+ " sleep 1",+ "done",+ "cat /tmp/floci-imds-proxy.log >&2 || true",+ "exit 1")};+ }++ static List<String> localAwsEnvironment(String region, String serviceEndpoint, String imdsEndpoint) {+ return List.of(+ "AWS_EC2_METADATA_SERVICE_ENDPOINT=" + imdsEndpoint,+ "AWS_ENDPOINT_URL=" + serviceEndpoint,+ "AWS_DEFAULT_REGION=" + region,+ "AWS_REGION=" + region,+ "AWS_ACCESS_KEY_ID=test",+ "AWS_SECRET_ACCESS_KEY=test",+ "AWS_SESSION_TOKEN=test-session-token");+ }++ private static String summarizeUserDataOutput(ByteArrayOutputStream output) {+ String text = output.toString(StandardCharsets.UTF_8).stripTrailing();+ if (text.isBlank()) {+ return "(no output)";+ }+ int start = Math.max(0, text.length() - 2048);+ return text.substring(start);+ }++ private void configureLinkLocalMetadataEndpoint(String containerId, String instanceId, String flociHost, int imdsPort) {+ try {+ ContainerExecResult install = execInContainerForResult(containerId, metadataProxyInstallCommand(), 180);+ if (install.exitCode() != 0) {+ LOG.warnv("Could not install IMDS proxy dependencies for EC2 instance {0}: {1}",+ instanceId, install.summary());+ return;+ }++ ContainerExecResult start = execInContainerForResult(containerId, metadataProxyStartCommand(flociHost, imdsPort), 30);+ if (start.exitCode() != 0) {+ LOG.warnv("Could not start link-local IMDS proxy for EC2 instance {0}: {1}",+ instanceId, start.summary());+ return;+ }++ LOG.infov("Configured link-local IMDS endpoint for EC2 instance {0}", instanceId);} catch (Exception e) {- LOG.warnv("UserData execution failed for EC2 instance {0}: {1}", instanceId, e.getMessage());+ LOG.warnv("Could not configure link-local IMDS endpoint for EC2 instance {0}: {1}", instanceId, e.getMessage());}}private void execInContainer(String containerId, String[] cmd, int timeoutSeconds) throws Exception {+ execInContainerForResult(containerId, cmd, timeoutSeconds);+ }++ private ContainerExecResult execInContainerForResult(String containerId, String[] cmd, int timeoutSeconds) throws Exception {String execId = dockerClient.execCreateCmd(containerId).withCmd(cmd).withAttachStdout(true)@@ -387,13 +624,31 @@ public class Ec2ContainerManager {.getId();CountDownLatch latch = new CountDownLatch(1);+ ByteArrayOutputStream output = new ByteArrayOutputStream();dockerClient.execStartCmd(execId).exec(new ResultCallback.Adapter<Frame>() {+ @Override+ public void onNext(Frame frame) {+ if (frame.getPayload() != null) {+ try { output.write(frame.getPayload()); } catch (IOException ignored) {}+ }+ }@Overridepublic void onComplete() { latch.countDown(); }@Overridepublic void onError(Throwable t) { latch.countDown(); }});- latch.await(timeoutSeconds, TimeUnit.SECONDS);+ boolean completed = latch.await(timeoutSeconds, TimeUnit.SECONDS);+ if (!completed) {+ return new ContainerExecResult(-1, "Timed out after " + timeoutSeconds + "s");+ }+ Long exitCode = dockerClient.inspectExecCmd(execId).exec().getExitCodeLong();+ return new ContainerExecResult(exitCode != null ? exitCode : -1, summarizeUserDataOutput(output));+ }++ record ContainerExecResult(long exitCode, String output) {+ String summary() {+ return output == null || output.isBlank() ? "(no output)" : output;+ }}private String getContainerBridgeIp(String containerId) {@@ -402,9 +657,9 @@ public class Ec2ContainerManager {if (inspect.getNetworkSettings() != null) {var networks = inspect.getNetworkSettings().getNetworks();if (networks != null) {- ContainerNetwork bridge = networks.get("bridge");- if (bridge != null && bridge.getIpAddress() != null && !bridge.getIpAddress().isBlank()) {- return bridge.getIpAddress();+ Optional<String> preferredIp = preferredMetadataSourceIp(networks);+ if (preferredIp.isPresent()) {+ return preferredIp.get();}}String ip = inspect.getNetworkSettings().getIpAddress();@@ -418,6 +673,41 @@ public class Ec2ContainerManager {return null;}+ private String waitForContainerBridgeIp(String containerId, String instanceId) throws InterruptedException {+ for (int i = 0; i < containerBridgeIpAttempts; i++) {+ String containerIp = getContainerBridgeIp(containerId);+ if (containerIp != null && !containerIp.isBlank()) {+ return containerIp;+ }+ Thread.sleep(containerBridgeIpPollMillis);+ }+ LOG.warnv("Timed out waiting for EC2 instance {0} container {1} bridge IP", instanceId, containerId);+ return null;+ }++ static Optional<String> preferredMetadataSourceIp(Map<String, ContainerNetwork> networks) {+ if (networks == null || networks.isEmpty()) {+ return Optional.empty();+ }+ Optional<String> configuredNetworkIp = networks.entrySet().stream()+ .filter(entry -> !"bridge".equals(entry.getKey()))+ .map(Map.Entry::getValue)+ .map(ContainerNetwork::getIpAddress)+ .filter(ip -> ip != null && !ip.isBlank())+ .findFirst();+ if (configuredNetworkIp.isPresent()) {+ return configuredNetworkIp;+ }+ ContainerNetwork bridge = networks.get("bridge");+ if (bridge != null && bridge.getIpAddress() != null && !bridge.getIpAddress().isBlank()) {+ return Optional.of(bridge.getIpAddress());+ }+ return networks.values().stream()+ .map(ContainerNetwork::getIpAddress)+ .filter(ip -> ip != null && !ip.isBlank())+ .findFirst();+ }+private byte[] buildSingleFileTar(String filename, byte[] content, int mode) throws IOException {ByteArrayOutputStream bos = new ByteArrayOutputStream();try (TarArchiveOutputStream tar = new TarArchiveOutputStream(bos)) {diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.javaindex f364c223ae..8a3359bc24 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java@@ -11,10 +11,13 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;+import java.net.URLDecoder;+import java.nio.charset.StandardCharsets;import java.time.Instant;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;import java.util.Map;+import java.util.Optional;import java.util.UUID;import java.util.concurrent.CompletableFuture;import java.util.concurrent.ConcurrentHashMap;@@ -33,6 +36,7 @@ public class Ec2MetadataServer {private static final Logger LOG = Logger.getLogger(Ec2MetadataServer.class);private static final DateTimeFormatter ISO = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'").withZone(ZoneOffset.UTC);+ private static final String INSTANCE_TAGS_PREFIX = "/latest/meta-data/tags/instance/";private final Vertx vertx;private final EmulatorConfig config;@@ -59,12 +63,16 @@ public class Ec2MetadataServer {}/** Called by Ec2ContainerManager when a container is terminated. */- public void unregisterContainer(String containerIp) {- if (containerIp != null) {- containerIpToInstance.remove(containerIp);+ public void unregisterContainer(String containerIp, Instance instance) {+ if (containerIp != null && instance != null) {+ containerIpToInstance.remove(containerIp, instance);}}+ Optional<Instance> registeredContainer(String containerIp) {+ return Optional.ofNullable(containerIpToInstance.get(containerIp));+ }+public CompletableFuture<Void> start() {CompletableFuture<Void> future = new CompletableFuture<>();int port = config.services().ec2().imdsPort();@@ -92,6 +100,9 @@ public class Ec2MetadataServer {router.get("/latest/meta-data/iam/info").handler(ctx -> handleIamInfo(ctx));router.get("/latest/meta-data/iam/security-credentials/").handler(ctx -> handleCredentialsList(ctx));router.get("/latest/meta-data/iam/security-credentials/:role").handler(ctx -> handleCredentials(ctx));+ router.get("/latest/meta-data/tags/instance").handler(ctx -> handleInstanceTagKeys(ctx));+ router.get("/latest/meta-data/tags/instance/").handler(ctx -> handleInstanceTagKeys(ctx));+ router.getWithRegex("/latest/meta-data/tags/instance/.+").handler(ctx -> handleInstanceTagValue(ctx));router.get("/latest/user-data").handler(ctx -> handleUserData(ctx));router.get("/latest/dynamic/instance-identity/document").handler(ctx -> handleIdentityDocument(ctx));@@ -245,6 +256,36 @@ public class Ec2MetadataServer {.end(body);}+ private void handleInstanceTagKeys(RoutingContext ctx) {+ Instance inst = resolveInstance(ctx);+ if (inst == null) {+ return;+ }+ ctx.response().setStatusCode(200)+ .putHeader("content-type", "text/plain")+ .end(instanceTagKeys(inst));+ }++ private void handleInstanceTagValue(RoutingContext ctx) {+ Instance inst = resolveInstance(ctx);+ if (inst == null) {+ return;+ }++ String path = ctx.request().path();+ String tagKey = path.length() <= INSTANCE_TAGS_PREFIX.length()+ ? ""+ : URLDecoder.decode(path.substring(INSTANCE_TAGS_PREFIX.length()), StandardCharsets.UTF_8);+ Optional<String> value = instanceTagValue(inst, tagKey);+ if (value.isEmpty()) {+ ctx.response().setStatusCode(404).end("not-found");+ return;+ }+ ctx.response().setStatusCode(200)+ .putHeader("content-type", "text/plain")+ .end(value.get());+ }+private void handleUserData(RoutingContext ctx) {Instance inst = resolveInstance(ctx);if (inst == null) {@@ -325,4 +366,33 @@ public class Ec2MetadataServer {private static String nvl(String s) {return s != null ? s : "";}++ static String instanceTagKeys(Instance instance) {+ StringBuilder tags = new StringBuilder();+ if (instance == null || instance.getTags() == null) {+ return "";+ }+ for (var tag : instance.getTags()) {+ if (tag.getKey() == null || tag.getKey().isBlank()) {+ continue;+ }+ if (!tags.isEmpty()) {+ tags.append("\n");+ }+ tags.append(tag.getKey());+ }+ return tags.toString();+ }++ static Optional<String> instanceTagValue(Instance instance, String key) {+ if (instance == null || instance.getTags() == null || key == null) {+ return Optional.empty();+ }+ for (var tag : instance.getTags()) {+ if (key.equals(tag.getKey())) {+ return Optional.of(nvl(tag.getValue()));+ }+ }+ return Optional.empty();+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.javaindex bd8e7389b4..468a28a0ef 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.ec2;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsNamespaces;import io.github.hectorvent.floci.core.common.XmlBuilder;+import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.services.ec2.model.*;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -27,10 +28,12 @@ public class Ec2QueryHandler {.withZone(ZoneOffset.UTC);private final Ec2Service service;+ private final EmulatorConfig config;@Inject- public Ec2QueryHandler(Ec2Service service) {+ public Ec2QueryHandler(Ec2Service service, EmulatorConfig config) {this.service = service;+ this.config = config;}public Response handle(String action, MultivaluedMap<String, String> params, String region) {@@ -248,6 +251,23 @@ public class Ec2QueryHandler {return tags;}+ private List<Tag> parseLaunchTemplateDataTagsForResource(MultivaluedMap<String, String> p, String resourceType) {+ List<Tag> tags = new ArrayList<>();+ for (int i = 1; ; i++) {+ String resType = p.getFirst("LaunchTemplateData.TagSpecification." + i + ".ResourceType");+ if (resType == null) break;+ if (resourceType.equals(resType)) {+ for (int j = 1; ; j++) {+ String key = p.getFirst("LaunchTemplateData.TagSpecification." + i + ".Tag." + j + ".Key");+ if (key == null) break;+ String value = p.getFirst("LaunchTemplateData.TagSpecification." + i + ".Tag." + j + ".Value");+ tags.add(new Tag(key, value));+ }+ }+ }+ return tags;+ }+private Response xmlResponse(String xml) {return Response.ok(xml).type(MediaType.APPLICATION_XML).build();}@@ -281,8 +301,7 @@ public class Ec2QueryHandler {userData = decodeUserData(userDataEncoded);}- // IamInstanceProfile- String iamInstanceProfileArn = p.getFirst("IamInstanceProfile.Arn");+ String iamInstanceProfileArn = resolveIamInstanceProfileArn(p);// Parse TagSpecificationsList<Tag> instanceTags = new ArrayList<>();@@ -1382,7 +1401,8 @@ public class Ec2QueryHandler {p.getFirst("LaunchTemplateData.KeyName"),parseLaunchTemplateSecurityGroupIds(p),decodeUserData(p.getFirst("LaunchTemplateData.UserData")),- parseTagsForResource(p, "launch-template"));+ parseTagsForResource(p, "launch-template"),+ parseLaunchTemplateDataTagsForResource(p, "instance"));XmlBuilder xml = new XmlBuilder().start("CreateLaunchTemplateResponse", AwsNamespaces.EC2).elem("requestId", UUID.randomUUID().toString())@@ -1396,12 +1416,13 @@ public class Ec2QueryHandler {region,p.getFirst("LaunchTemplateId"),p.getFirst("LaunchTemplateName"),+ p.getFirst("SourceVersion"),p.getFirst("LaunchTemplateData.ImageId"),p.getFirst("LaunchTemplateData.InstanceType"),p.getFirst("LaunchTemplateData.KeyName"),parseLaunchTemplateSecurityGroupIds(p),decodeUserData(p.getFirst("LaunchTemplateData.UserData")),- p.getFirst("SourceVersion"));+ parseLaunchTemplateDataTagsForResource(p, "instance"));XmlBuilder xml = new XmlBuilder().start("CreateLaunchTemplateVersionResponse", AwsNamespaces.EC2).elem("requestId", UUID.randomUUID().toString())@@ -1695,6 +1716,18 @@ public class Ec2QueryHandler {return xml.build();}+ private String resolveIamInstanceProfileArn(MultivaluedMap<String, String> p) {+ String arn = p.getFirst("IamInstanceProfile.Arn");+ if (arn != null && !arn.isBlank()) {+ return arn;+ }+ String name = p.getFirst("IamInstanceProfile.Name");+ if (name == null || name.isBlank()) {+ return null;+ }+ return "arn:aws:iam::" + config.defaultAccountId() + ":instance-profile/" + name;+ }+private String vpcXml(Vpc vpc) {XmlBuilder xml = new XmlBuilder().elem("vpcId", vpc.getVpcId())@@ -1872,8 +1905,16 @@ public class Ec2QueryHandler {for (String securityGroupId : launchTemplate.getSecurityGroupIds()) {xml.elem("item", securityGroupId);}- xml.end("securityGroupIdSet")- .end("launchTemplateData");+ xml.end("securityGroupIdSet");+ if (launchTemplate.getInstanceTags() != null && !launchTemplate.getInstanceTags().isEmpty()) {+ xml.start("tagSpecificationSet")+ .start("item")+ .elem("resourceType", "instance")+ .raw(tagSetXml(launchTemplate.getInstanceTags()))+ .end("item")+ .end("tagSpecificationSet");+ }+ xml.end("launchTemplateData");return xml.build();}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex cd4e6d7b69..3d35ffaec6 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -61,6 +61,7 @@ import io.github.hectorvent.floci.services.ec2.model.VolumeAttachment;import io.github.hectorvent.floci.services.ec2.model.Vpc;import io.github.hectorvent.floci.services.ec2.model.VpcCidrBlockAssociation;import io.github.hectorvent.floci.services.ec2.model.VpcEndpoint;+import jakarta.annotation.PostConstruct;import io.github.hectorvent.floci.services.ec2.model.LaunchSpecification;import io.github.hectorvent.floci.services.ec2.model.SpotInstanceRequest;import jakarta.enterprise.context.ApplicationScoped;@@ -164,6 +165,37 @@ public class Ec2Service {this.tags = tags;}+ @PostConstruct+ void restoreMetadataRegistrations() {+ if (config.services().ec2().mock()) {+ return;+ }++ int restored = 0;+ for (String key : instances.keys()) {+ Instance instance = instances.get(key).orElse(null);+ if (!needsMetadataRegistration(instance)) {+ continue;+ }+ if (containerManager.restoreMetadataRegistration(instance)) {+ instances.put(key, instance);+ restored++;+ }+ }+ if (restored > 0) {+ LOG.infov("Restored IMDS metadata registration for {0} EC2 container(s)", restored);+ }+ }++ private static boolean needsMetadataRegistration(Instance instance) {+ if (instance == null || instance.getDockerContainerId() == null) {+ return false;+ }+ String state = instance.getState() != null ? instance.getState().getName() : null;+ return state == null+ || (!"shutting-down".equals(state) && !"terminated".equals(state) && !"stopping".equals(state));+ }+// ─── Default resource seeding ──────────────────────────────────────────────public void ensureDefaultResources(String region) {@@ -446,7 +478,10 @@ public class Ec2Service {if (config.services().ec2().mock()) {instances.scan(k -> true).stream().filter(i -> i.getRegion().equals(region) && "pending".equals(i.getState().getName()))- .forEach(i -> i.setState(InstanceState.running()));+ .forEach(i -> {+ i.setState(InstanceState.running());+ instances.put(key(i.getRegion(), i.getInstanceId()), i);+ });}List<Instance> matched = instances.scan(k -> true).stream().filter(i -> i.getRegion().equals(region))@@ -584,7 +619,10 @@ public class Ec2Service {instances.scan(k -> true).stream().filter(i -> i.getRegion().equals(region) && "pending".equals(i.getState().getName())).filter(i -> instanceIds.isEmpty() || instanceIds.contains(i.getInstanceId()))- .forEach(i -> i.setState(InstanceState.running()));+ .forEach(i -> {+ i.setState(InstanceState.running());+ instances.put(key(i.getRegion(), i.getInstanceId()), i);+ });}return instances.scan(k -> true).stream().filter(i -> i.getRegion().equals(region))@@ -1076,7 +1114,15 @@ public class Ec2Service {public boolean isInstanceContainerRunning(String instanceId) {Instance instance = findInstanceById(instanceId);- return instance != null && containerManager.isContainerRunning(instance.getDockerContainerId());+ if (instance == null) {+ return false;+ }+ if (config.services().ec2().mock()) {+ String state = instance.getState() != null ? instance.getState().getName() : null;+ return state == null+ || (!"shutting-down".equals(state) && !"terminated".equals(state) && !"stopping".equals(state));+ }+ return containerManager.isContainerRunning(instance.getDockerContainerId());}public KeyPair findKeyPair(String region, String keyName) {@@ -1110,7 +1156,7 @@ public class Ec2Service {public LaunchTemplate createLaunchTemplate(String region, String name, String imageId,String instanceType, String keyName,List<String> securityGroupIds, String userData,- List<Tag> launchTemplateTags) {+ List<Tag> launchTemplateTags, List<Tag> instanceTags) {ensureDefaultResources(region);if (name == null || name.isBlank()) {throw new AwsException("MissingParameter", "The request must contain the parameter LaunchTemplateName", 400);@@ -1139,17 +1185,22 @@ public class Ec2Service {launchTemplate.setTags(new ArrayList<>(launchTemplateTags));tags.put(launchTemplate.getLaunchTemplateId(), new ArrayList<>(launchTemplateTags));}+ if (instanceTags != null && !instanceTags.isEmpty()) {+ launchTemplate.setInstanceTags(new ArrayList<>(instanceTags));+ }launchTemplate.getVersions().put("1", dataFrom(launchTemplate));launchTemplates.put(key(region, launchTemplate.getLaunchTemplateId()), launchTemplate);return launchTemplate;}public LaunchTemplate createLaunchTemplateVersion(String region, String id, String name,+ String sourceVersion,String imageId, String instanceType, String keyName,List<String> securityGroupIds, String userData,- String sourceVersion) {+ List<Tag> instanceTags) {ensureDefaultResources(region);LaunchTemplate launchTemplate = findLaunchTemplate(region, id, name);+ ensureLaunchTemplateVersions(launchTemplate);int latestVersion = parseLaunchTemplateVersion(launchTemplate.getLatestVersionNumber()) + 1;LaunchTemplateData data = new LaunchTemplateData(versionData(launchTemplate,resolveLaunchTemplateVersion(launchTemplate, sourceVersion, launchTemplate.getLatestVersionNumber())));@@ -1169,8 +1220,12 @@ public class Ec2Service {if (securityGroupIds != null && !securityGroupIds.isEmpty()) {data.setSecurityGroupIds(securityGroupIds);}+ if (instanceTags != null && !instanceTags.isEmpty()) {+ data.setInstanceTags(instanceTags);+ }launchTemplate.getVersions().put(String.valueOf(latestVersion), data);applyData(launchTemplate, data);+ launchTemplates.put(key(region, launchTemplate.getLaunchTemplateId()), launchTemplate);return launchTemplate;}@@ -1198,6 +1253,7 @@ public class Ec2Service {public LaunchTemplate modifyLaunchTemplate(String region, String id, String name, String defaultVersion) {ensureDefaultResources(region);LaunchTemplate launchTemplate = findLaunchTemplate(region, id, name);+ ensureLaunchTemplateVersions(launchTemplate);if (defaultVersion != null && !defaultVersion.isBlank()) {String resolved = switch (defaultVersion) {case "$Latest" -> launchTemplate.getLatestVersionNumber();@@ -1206,12 +1262,14 @@ public class Ec2Service {};int requested = parseLaunchTemplateVersion(resolved);int latest = parseLaunchTemplateVersion(launchTemplate.getLatestVersionNumber());- if (requested < 1 || requested > latest) {+ if (requested < 1 || requested > latest+ || !launchTemplate.getVersions().containsKey(String.valueOf(requested))) {throw new AwsException("InvalidLaunchTemplateVersion.NotFound","The specified launch template version does not exist.", 400);}launchTemplate.setDefaultVersionNumber(String.valueOf(requested));}+ launchTemplates.put(key(region, launchTemplate.getLaunchTemplateId()), launchTemplate);return launchTemplate;}@@ -1260,11 +1318,17 @@ public class Ec2Service {}}+ private void ensureLaunchTemplateVersions(LaunchTemplate launchTemplate) {+ if (!launchTemplate.getVersions().isEmpty()) {+ return;+ }+ launchTemplate.getVersions().put(launchTemplate.getLatestVersionNumber(), dataFrom(launchTemplate));+ launchTemplates.put(key(launchTemplate.getRegion(), launchTemplate.getLaunchTemplateId()), launchTemplate);+ }+private String resolveLaunchTemplateVersion(LaunchTemplate launchTemplate, String requestedVersion,String defaultWhenMissing) {- if (launchTemplate.getVersions().isEmpty()) {- launchTemplate.getVersions().put(launchTemplate.getLatestVersionNumber(), dataFrom(launchTemplate));- }+ ensureLaunchTemplateVersions(launchTemplate);String candidate = requestedVersion == null || requestedVersion.isBlank() ? defaultWhenMissing : requestedVersion;String resolved = switch (candidate) {case "$Latest" -> launchTemplate.getLatestVersionNumber();@@ -1291,6 +1355,7 @@ public class Ec2Service {data.setKeyName(launchTemplate.getKeyName());data.setUserData(launchTemplate.getUserData());data.setSecurityGroupIds(launchTemplate.getSecurityGroupIds());+ data.setInstanceTags(launchTemplate.getInstanceTags());return data;}@@ -1300,6 +1365,7 @@ public class Ec2Service {launchTemplate.setKeyName(data.getKeyName());launchTemplate.setUserData(data.getUserData());launchTemplate.setSecurityGroupIds(new ArrayList<>(data.getSecurityGroupIds()));+ launchTemplate.setInstanceTags(data.getInstanceTags());}private LaunchTemplate copyForVersion(LaunchTemplate source, String versionNumber) {@@ -2036,6 +2102,8 @@ public class Ec2Service {case "group-id" -> ni.getGroups().stream().anyMatch(g -> matchesValue(values, g.getGroupId()));case "status" -> matchesValue(values, ni.getStatus());+ case "attachment.instance-id" -> ni.getAttachment() != null+ && matchesValue(values, ni.getAttachment().getInstanceId());case "private-ip-address" ->matchesValue(values, ni.getPrivateIpAddress()) ||ni.getPrivateIpAddresses().stream()diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplate.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplate.javaindex a7acc08cc8..91f9d9d39f 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplate.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplate.java@@ -26,6 +26,7 @@ public class LaunchTemplate {private String userData;private List<String> securityGroupIds = new ArrayList<>();private List<Tag> tags = new ArrayList<>();+ private List<Tag> instanceTags = new ArrayList<>();private Map<String, LaunchTemplateData> versions = new LinkedHashMap<>();public LaunchTemplate() {}@@ -69,6 +70,11 @@ public class LaunchTemplate {public List<Tag> getTags() { return tags; }public void setTags(List<Tag> tags) { this.tags = tags; }+ public List<Tag> getInstanceTags() { return instanceTags; }+ public void setInstanceTags(List<Tag> instanceTags) {+ this.instanceTags = instanceTags != null ? new ArrayList<>(instanceTags) : new ArrayList<>();+ }+public Map<String, LaunchTemplateData> getVersions() { return versions; }public void setVersions(Map<String, LaunchTemplateData> versions) {this.versions = versions != null ? new LinkedHashMap<>(versions) : new LinkedHashMap<>();diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplateData.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplateData.javaindex 5f167aa1f3..e8963bee2c 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplateData.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplateData.java@@ -15,6 +15,7 @@ public class LaunchTemplateData {private String keyName;private String userData;private List<String> securityGroupIds = new ArrayList<>();+ private List<Tag> instanceTags = new ArrayList<>();public LaunchTemplateData() {}@@ -24,6 +25,7 @@ public class LaunchTemplateData {this.keyName = source.keyName;this.userData = source.userData;this.securityGroupIds = new ArrayList<>(source.securityGroupIds);+ this.instanceTags = new ArrayList<>(source.instanceTags);}public String getImageId() { return imageId; }@@ -42,4 +44,9 @@ public class LaunchTemplateData {public void setSecurityGroupIds(List<String> securityGroupIds) {this.securityGroupIds = securityGroupIds != null ? new ArrayList<>(securityGroupIds) : new ArrayList<>();}++ public List<Tag> getInstanceTags() { return instanceTags; }+ public void setInstanceTags(List<Tag> instanceTags) {+ this.instanceTags = instanceTags != null ? new ArrayList<>(instanceTags) : new ArrayList<>();+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingIntegrationTest.javaindex f036c6acad..c43a1ed3da 100644--- a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingIntegrationTest.java@@ -7,6 +7,7 @@ import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;import static io.restassured.RestAssured.given;+import static org.hamcrest.MatcherAssert.assertThat;import static org.hamcrest.Matchers.*;@QuarkusTest@@ -17,6 +18,8 @@ class AutoScalingIntegrationTest {"AWS4-HMAC-SHA256 Credential=test/20260501/us-east-1/autoscaling/aws4_request";private static String policyArn;+ private static String instanceRefreshId;+ private static String pagedInstanceRefreshId;// ── Launch Configurations ─────────────────────────────────────────────────@@ -386,10 +389,216 @@ class AutoScalingIntegrationTest {.body(containsString("DescribeScalingActivitiesResponse"));}+ @Test+ @Order(21)+ void createAutoScalingGroupWithLaunchTemplateId() {+ given()+ .formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", "my-lt-asg")+ .formParam("LaunchTemplate.LaunchTemplateId", "lt-0123456789abcdef0")+ .formParam("LaunchTemplate.Version", "$Latest")+ .formParam("MinSize", "0")+ .formParam("MaxSize", "1")+ .formParam("DesiredCapacity", "0")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .formParam("VPCZoneIdentifier", "subnet-12345678,subnet-87654321")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("CreateAutoScalingGroupResponse"));++ given()+ .formParam("Action", "CreateOrUpdateTags")+ .formParam("Tags.member.1.ResourceId", "my-lt-asg")+ .formParam("Tags.member.1.ResourceType", "auto-scaling-group")+ .formParam("Tags.member.1.Key", "owner")+ .formParam("Tags.member.1.Value", "sample-app")+ .formParam("Tags.member.1.PropagateAtLaunch", "true")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("CreateOrUpdateTagsResponse"));+ }++ @Test+ @Order(22)+ void describeAutoScalingGroupWithLaunchTemplateId() {+ given()+ .formParam("Action", "DescribeAutoScalingGroups")+ .formParam("AutoScalingGroupNames.member.1", "my-lt-asg")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("my-lt-asg"))+ .body(containsString("<LaunchTemplateId>lt-0123456789abcdef0</LaunchTemplateId>"))+ .body(containsString("<Version>$Latest</Version>"))+ .body(containsString("<VPCZoneIdentifier>subnet-12345678,subnet-87654321</VPCZoneIdentifier>"))+ .body(containsString("owner"))+ .body(containsString("sample-app"));++ given()+ .formParam("Action", "DeleteTags")+ .formParam("Tags.member.1.ResourceId", "my-lt-asg")+ .formParam("Tags.member.1.ResourceType", "auto-scaling-group")+ .formParam("Tags.member.1.Key", "owner")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("DeleteTagsResponse"));++ given()+ .formParam("Action", "DescribeAutoScalingGroups")+ .formParam("AutoScalingGroupNames.member.1", "my-lt-asg")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(not(containsString("sample-app")));+ }++ @Test+ @Order(23)+ void startInstanceRefresh() {+ instanceRefreshId = given()+ .formParam("Action", "StartInstanceRefresh")+ .formParam("AutoScalingGroupName", "my-lt-asg")+ .formParam("Strategy", "Rolling")+ .formParam("DesiredConfiguration.LaunchTemplate.LaunchTemplateId", "lt-0fedcba9876543210")+ .formParam("DesiredConfiguration.LaunchTemplate.Version", "2")+ .formParam("Preferences.MinHealthyPercentage", "90")+ .formParam("Preferences.MaxHealthyPercentage", "120")+ .formParam("Preferences.InstanceWarmup", "200")+ .formParam("Preferences.SkipMatching", "true")+ .formParam("Preferences.AutoRollback", "true")+ .formParam("Preferences.CheckpointPercentages.member.1", "50")+ .formParam("Preferences.CheckpointPercentages.member.2", "100")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("StartInstanceRefreshResponse"))+ .body(containsString("InstanceRefreshId"))+ .extract().xmlPath()+ .getString("StartInstanceRefreshResponse.StartInstanceRefreshResult.InstanceRefreshId");++ assertThat(instanceRefreshId, not(emptyOrNullString()));+ }++ @Test+ @Order(24)+ void describeInstanceRefreshes() {+ String body = given()+ .formParam("Action", "DescribeInstanceRefreshes")+ .formParam("AutoScalingGroupName", "my-lt-asg")+ .formParam("InstanceRefreshIds.member.1", instanceRefreshId)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("DescribeInstanceRefreshesResponse"))+ .extract().body().asString();++ assertThat(body, containsString(instanceRefreshId));+ assertThat(body, containsString("<AutoScalingGroupName>my-lt-asg</AutoScalingGroupName>"));+ assertThat(body, containsString("<Status>Successful</Status>"));+ assertThat(body, containsString("<PercentageComplete>100</PercentageComplete>"));+ assertThat(body, containsString("<InstancesToUpdate>0</InstancesToUpdate>"));+ assertThat(body, containsString("<Strategy>Rolling</Strategy>"));+ assertThat(body, containsString("<LaunchTemplateId>lt-0fedcba9876543210</LaunchTemplateId>"));+ assertThat(body, containsString("<Version>2</Version>"));+ assertThat(body, containsString("<MinHealthyPercentage>90</MinHealthyPercentage>"));+ assertThat(body, containsString("<MaxHealthyPercentage>120</MaxHealthyPercentage>"));+ assertThat(body, containsString("<InstanceWarmup>200</InstanceWarmup>"));+ assertThat(body, containsString("<SkipMatching>true</SkipMatching>"));+ assertThat(body, containsString("<AutoRollback>true</AutoRollback>"));+ assertThat(body, containsString("<CheckpointPercentages>"));++ given()+ .formParam("Action", "DescribeAutoScalingGroups")+ .formParam("AutoScalingGroupNames.member.1", "my-lt-asg")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<LaunchTemplateId>lt-0fedcba9876543210</LaunchTemplateId>"))+ .body(containsString("<Version>2</Version>"));+ }++ @Test+ @Order(25)+ void describeInstanceRefreshesPaginatesNewestFirst() {+ pagedInstanceRefreshId = given()+ .formParam("Action", "StartInstanceRefresh")+ .formParam("AutoScalingGroupName", "my-lt-asg")+ .formParam("Preferences.SkipMatching", "true")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().xmlPath()+ .getString("StartInstanceRefreshResponse.StartInstanceRefreshResult.InstanceRefreshId");++ String firstPage = given()+ .formParam("Action", "DescribeInstanceRefreshes")+ .formParam("AutoScalingGroupName", "my-lt-asg")+ .formParam("MaxRecords", "1")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<NextToken>1</NextToken>"))+ .extract().body().asString();++ assertThat(firstPage, containsString(pagedInstanceRefreshId));+ assertThat(firstPage, not(containsString(instanceRefreshId)));++ given()+ .formParam("Action", "DescribeInstanceRefreshes")+ .formParam("AutoScalingGroupName", "my-lt-asg")+ .formParam("MaxRecords", "1")+ .formParam("NextToken", "1")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString(instanceRefreshId))+ .body(not(containsString("<NextToken>")));+ }++ @Test+ @Order(26)+ void deleteLaunchTemplateAutoScalingGroup() {+ given()+ .formParam("Action", "DeleteAutoScalingGroup")+ .formParam("AutoScalingGroupName", "my-lt-asg")+ .formParam("ForceDelete", "true")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("DeleteAutoScalingGroupResponse"));+ }+// ── Cleanup ───────────────────────────────────────────────────────────────@Test- @Order(21)+ @Order(27)void deleteAutoScalingGroup() {given().formParam("Action", "DeleteAutoScalingGroup")@@ -404,7 +613,7 @@ class AutoScalingIntegrationTest {}@Test- @Order(22)+ @Order(28)void deleteLaunchConfiguration() {given().formParam("Action", "DeleteLaunchConfiguration")@@ -418,7 +627,7 @@ class AutoScalingIntegrationTest {}@Test- @Order(23)+ @Order(29)void describeAutoScalingGroupsEmpty() {given().formParam("Action", "DescribeAutoScalingGroups")diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandlerTest.javanew file mode 100644index 0000000000..4c67fc3986--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingQueryHandlerTest.java@@ -0,0 +1,129 @@+package io.github.hectorvent.floci.services.autoscaling;++import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.autoscaling.model.AsgInstance;+import jakarta.ws.rs.core.MultivaluedHashMap;+import jakarta.ws.rs.core.Response;+import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++class AutoScalingQueryHandlerTest {++ private static final String REGION = "us-east-1";++ @Test+ void startAndDescribeInstanceRefreshUseAwsQueryXmlShape() {+ AutoScalingService service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION,+ "query-asg",+ null,+ "lt-original",+ null,+ "1",+ 0,+ 3,+ 1,+ 300,+ List.of("us-east-1a"),+ List.of(),+ List.of(),+ List.of(),+ "EC2",+ 0,+ List.of("Default"),+ java.util.Map.of());++ AutoScalingQueryHandler handler = new AutoScalingQueryHandler(service);+ MultivaluedHashMap<String, String> startParams = new MultivaluedHashMap<>();+ startParams.add("AutoScalingGroupName", "query-asg");+ startParams.add("DesiredConfiguration.LaunchTemplate.LaunchTemplateId", "lt-updated");+ startParams.add("DesiredConfiguration.LaunchTemplate.Version", "2");+ startParams.add("Preferences.MinHealthyPercentage", "90");+ startParams.add("Preferences.SkipMatching", "true");++ Response startResponse = handler.handle("StartInstanceRefresh", startParams, REGION);++ assertEquals(200, startResponse.getStatus());+ String startXml = (String) startResponse.getEntity();+ assertTrue(startXml.contains("<StartInstanceRefreshResponse"));+ assertTrue(startXml.contains("<StartInstanceRefreshResult>"));+ assertTrue(startXml.contains("<InstanceRefreshId>"));+ String refreshId = service.describeInstanceRefreshes(REGION, "query-asg", List.of(), null, null)+ .instanceRefreshes().getFirst().getInstanceRefreshId();++ MultivaluedHashMap<String, String> describeParams = new MultivaluedHashMap<>();+ describeParams.add("AutoScalingGroupName", "query-asg");+ describeParams.add("InstanceRefreshIds.member.1", refreshId);++ Response describeResponse = handler.handle("DescribeInstanceRefreshes", describeParams, REGION);++ assertEquals(200, describeResponse.getStatus());+ String describeXml = (String) describeResponse.getEntity();+ assertTrue(describeXml.contains("<DescribeInstanceRefreshesResponse"));+ assertTrue(describeXml.contains("<InstanceRefreshes>"));+ assertTrue(describeXml.contains("<InstanceRefreshId>" + refreshId + "</InstanceRefreshId>"));+ assertTrue(describeXml.contains("<AutoScalingGroupName>query-asg</AutoScalingGroupName>"));+ assertTrue(describeXml.contains("<Status>Successful</Status>"));+ assertTrue(describeXml.contains("<PercentageComplete>100</PercentageComplete>"));+ assertTrue(describeXml.contains("<InstancesToUpdate>0</InstancesToUpdate>"));+ assertTrue(describeXml.contains("<DesiredConfiguration>"));+ assertTrue(describeXml.contains("<LaunchTemplateId>lt-updated</LaunchTemplateId>"));+ assertTrue(describeXml.contains("<Version>2</Version>"));+ assertTrue(describeXml.contains("<Preferences>"));+ assertTrue(describeXml.contains("<MinHealthyPercentage>90</MinHealthyPercentage>"));+ assertTrue(describeXml.contains("<SkipMatching>true</SkipMatching>"));+ }++ @Test+ void describeAutoScalingGroupsIncludesInstanceLaunchTemplateMetadata() {+ AutoScalingService service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION,+ "query-asg",+ null,+ "lt-current",+ null,+ "$Latest",+ 0,+ 3,+ 1,+ 300,+ List.of("us-east-1a"),+ List.of(),+ List.of(),+ List.of(),+ "EC2",+ 0,+ List.of("Default"),+ java.util.Map.of());+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId("i-current");+ instance.setAvailabilityZone("us-east-1a");+ instance.setLifecycleState("InService");+ instance.setHealthStatus("Healthy");+ instance.setLaunchTemplateId("lt-current");+ instance.setLaunchTemplateVersion("7");+ service.describeAutoScalingGroups(REGION, List.of("query-asg"))+ .getFirst()+ .getInstances()+ .add(instance);++ AutoScalingQueryHandler handler = new AutoScalingQueryHandler(service);+ MultivaluedHashMap<String, String> params = new MultivaluedHashMap<>();+ params.add("AutoScalingGroupNames.member.1", "query-asg");++ Response response = handler.handle("DescribeAutoScalingGroups", params, REGION);++ assertEquals(200, response.getStatus());+ String xml = (String) response.getEntity();+ assertTrue(xml.contains("<InstanceId>i-current</InstanceId>"));+ assertTrue(xml.contains("<LaunchTemplate>"));+ assertTrue(xml.contains("<LaunchTemplateId>lt-current</LaunchTemplateId>"));+ assertTrue(xml.contains("<Version>7</Version>"));+ }+}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.javanew file mode 100644index 0000000000..6c98b19c59--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingReconcilerTest.java@@ -0,0 +1,219 @@+package io.github.hectorvent.floci.services.autoscaling;++import io.github.hectorvent.floci.services.autoscaling.model.AsgInstance;+import io.github.hectorvent.floci.services.autoscaling.model.AutoScalingGroup;+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.InstanceState;+import io.github.hectorvent.floci.services.ec2.model.LaunchTemplate;+import io.github.hectorvent.floci.services.ec2.model.Reservation;+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;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.Mockito.eq;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.times;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++class AutoScalingReconcilerTest {++ @Test+ void pendingInstancesCountAsActiveCapacity() {+ AutoScalingGroup asg = new AutoScalingGroup();+ asg.getInstances().add(instance("Pending"));+ asg.getInstances().add(instance("InService"));+ asg.getInstances().add(instance("Terminating"));+ asg.getInstances().add(instance("Terminated"));+ asg.getInstances().add(instance("Detached"));++ assertEquals(2, AutoScalingReconciler.activeCapacity(asg));+ }++ @Test+ void reconcileCompletesSettledInstanceRefreshes() {+ AutoScalingService asgService = mock(AutoScalingService.class);+ Ec2Service ec2Service = mock(Ec2Service.class);+ ElbV2Service elbV2Service = mock(ElbV2Service.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(asgService, ec2Service, elbV2Service);+ AutoScalingGroup asg = new AutoScalingGroup();+ asg.setRegion("us-east-1");+ asg.setAutoScalingGroupName("app-asg");+ asg.setDesiredCapacity(0);++ reconciler.reconcile(asg);++ verify(asgService).completeInstanceRefreshIfSettled("us-east-1", "app-asg");+ }++ @Test+ void scaleOutUsesRequestedLaunchTemplateVersionData() {+ AutoScalingService asgService = mock(AutoScalingService.class);+ Ec2Service ec2Service = mock(Ec2Service.class);+ ElbV2Service elbV2Service = mock(ElbV2Service.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(asgService, ec2Service, elbV2Service);+ AutoScalingGroup asg = new AutoScalingGroup();+ asg.setRegion("us-east-1");+ asg.setAutoScalingGroupName("app-asg");+ asg.setDesiredCapacity(1);+ asg.setLaunchTemplateId("lt-123");+ asg.setLaunchTemplateVersion("1");++ LaunchTemplate launchTemplate = new LaunchTemplate();+ launchTemplate.setLaunchTemplateId("lt-123");+ LaunchTemplate version = new LaunchTemplate();+ version.setLatestVersionNumber("1");+ version.setImageId("ami-version-1");+ version.setInstanceType("t3.micro");+ when(ec2Service.describeLaunchTemplates("us-east-1", List.of("lt-123"), List.of(), Map.of()))+ .thenReturn(List.of(launchTemplate));+ when(ec2Service.describeLaunchTemplateVersions("us-east-1", "lt-123", null, List.of("1")))+ .thenReturn(List.of(version));+ Instance ec2Instance = new Instance();+ ec2Instance.setInstanceId("i-launched");+ Reservation reservation = new Reservation();+ reservation.setInstances(List.of(ec2Instance));+ when(ec2Service.runInstances(eq("us-east-1"), eq("ami-version-1"), eq("t3.micro"),+ eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null),+ eq(List.of()), eq(null), eq(null))).thenReturn(reservation);++ reconciler.reconcile(asg);++ assertEquals(1, asg.getInstances().size());+ assertEquals("i-launched", asg.getInstances().getFirst().getInstanceId());+ assertEquals("lt-123", asg.getInstances().getFirst().getLaunchTemplateId());+ assertEquals("1", asg.getInstances().getFirst().getLaunchTemplateVersion());+ verify(ec2Service).runInstances(eq("us-east-1"), eq("ami-version-1"), eq("t3.micro"),+ eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null),+ eq(List.of()), eq(null), eq(null));+ }++ @Test+ void scaleOutStoresResolvedLaunchTemplateVersionForAliases() {+ AutoScalingService asgService = mock(AutoScalingService.class);+ Ec2Service ec2Service = mock(Ec2Service.class);+ ElbV2Service elbV2Service = mock(ElbV2Service.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(asgService, ec2Service, elbV2Service);+ AutoScalingGroup asg = new AutoScalingGroup();+ asg.setRegion("us-east-1");+ asg.setAutoScalingGroupName("app-asg");+ asg.setDesiredCapacity(1);+ asg.setLaunchTemplateId("lt-123");+ asg.setLaunchTemplateVersion("$Latest");++ LaunchTemplate launchTemplate = new LaunchTemplate();+ launchTemplate.setLaunchTemplateId("lt-123");+ LaunchTemplate version = new LaunchTemplate();+ version.setLatestVersionNumber("7");+ version.setImageId("ami-version-7");+ version.setInstanceType("t3.micro");+ when(ec2Service.describeLaunchTemplates("us-east-1", List.of("lt-123"), List.of(), Map.of()))+ .thenReturn(List.of(launchTemplate));+ when(ec2Service.describeLaunchTemplateVersions("us-east-1", "lt-123", null, List.of("$Latest")))+ .thenReturn(List.of(version));+ Instance ec2Instance = new Instance();+ ec2Instance.setInstanceId("i-launched");+ Reservation reservation = new Reservation();+ reservation.setInstances(List.of(ec2Instance));+ when(ec2Service.runInstances(eq("us-east-1"), eq("ami-version-7"), eq("t3.micro"),+ eq(1), eq(1), eq(null), eq(List.of()), eq(null), eq(null),+ eq(List.of()), eq(null), eq(null))).thenReturn(reservation);++ reconciler.reconcile(asg);++ assertEquals("$Latest", asg.getLaunchTemplateVersion());+ assertEquals("7", asg.getInstances().getFirst().getLaunchTemplateVersion());+ }++ @Test+ void reconcileDeregistersTargetsThatAreNotActiveAsgInstances() {+ AutoScalingService asgService = mock(AutoScalingService.class);+ Ec2Service ec2Service = mock(Ec2Service.class);+ ElbV2Service elbV2Service = mock(ElbV2Service.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(asgService, ec2Service, elbV2Service);+ AutoScalingGroup asg = new AutoScalingGroup();+ asg.setRegion("us-east-1");+ asg.setAutoScalingGroupName("app-asg");+ asg.setDesiredCapacity(1);+ asg.setTargetGroupARNs(List.of("arn:aws:elasticloadbalancing:us-east-1:000000000000:targetgroup/app/123"));+ asg.getInstances().add(instance("i-active", "InService"));+ when(ec2Service.isInstanceContainerRunning("i-active")).thenReturn(true);+ when(elbV2Service.describeTargetHealth(asg.getRegion(), asg.getTargetGroupARNs().getFirst(), List.of()))+ .thenReturn(List.of(targetHealth("i-active"), targetHealth("i-stale")));++ reconciler.reconcile(asg);++ ArgumentCaptor<List<TargetDescription>> targets = ArgumentCaptor.captor();+ verify(elbV2Service).deregisterTargets(+ eq(asg.getRegion()),+ eq(asg.getTargetGroupARNs().getFirst()),+ targets.capture());+ assertEquals(1, targets.getValue().size());+ assertEquals("i-stale", targets.getValue().getFirst().getId());+ verify(asgService).saveAutoScalingGroup(asg);+ verify(ec2Service, never()).terminateInstances(asg.getRegion(), List.of("i-active"));+ }++ @Test+ void reconcilePromotesPendingAsgInstanceWhenEc2InstanceIsRunning() {+ AutoScalingService asgService = mock(AutoScalingService.class);+ Ec2Service ec2Service = mock(Ec2Service.class);+ ElbV2Service elbV2Service = mock(ElbV2Service.class);+ AutoScalingReconciler reconciler = new AutoScalingReconciler(asgService, ec2Service, elbV2Service);+ AutoScalingGroup asg = new AutoScalingGroup();+ asg.setRegion("us-east-1");+ asg.setAutoScalingGroupName("app-asg");+ asg.setDesiredCapacity(1);+ asg.getInstances().add(instance("i-pending", "Pending"));++ Instance ec2Instance = new Instance();+ ec2Instance.setInstanceId("i-pending");+ ec2Instance.setState(InstanceState.running());+ Reservation reservation = new Reservation();+ reservation.setInstances(List.of(ec2Instance));+ when(ec2Service.describeInstances(asg.getRegion(), List.of("i-pending"), null))+ .thenReturn(List.of(reservation));+ when(ec2Service.isInstanceContainerRunning("i-pending")).thenReturn(true);++ reconciler.reconcile(asg);++ assertEquals("InService", asg.getInstances().getFirst().getLifecycleState());+ assertEquals("Healthy", asg.getInstances().getFirst().getHealthStatus());+ verify(asgService).recordActivity(+ eq(asg.getRegion()),+ eq(asg.getAutoScalingGroupName()),+ eq("Launching a new EC2 instance: i-pending"),+ eq("An instance was started in response to a desired capacity change."),+ eq("Successful"));+ verify(asgService, times(2)).saveAutoScalingGroup(asg);+ }++ private static AsgInstance instance(String lifecycleState) {+ AsgInstance instance = new AsgInstance();+ instance.setLifecycleState(lifecycleState);+ return instance;+ }++ private static AsgInstance instance(String instanceId, String lifecycleState) {+ AsgInstance instance = instance(lifecycleState);+ instance.setInstanceId(instanceId);+ instance.setHealthStatus("Healthy");+ return instance;+ }++ private static TargetHealth targetHealth(String instanceId) {+ TargetDescription target = new TargetDescription();+ target.setId(instanceId);+ TargetHealth health = new TargetHealth();+ health.setTarget(target);+ return health;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.javanew file mode 100644index 0000000000..58e8260cf8--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.java@@ -0,0 +1,334 @@+package io.github.hectorvent.floci.services.autoscaling;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.autoscaling.model.AsgInstance;+import io.github.hectorvent.floci.services.autoscaling.model.InstanceRefresh;+import io.github.hectorvent.floci.services.ec2.Ec2Service;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verify;++class AutoScalingServiceTest {++ private static final String REGION = "us-east-1";+ private AutoScalingService service;++ @BeforeEach+ void setUp() {+ service = new AutoScalingService();+ service.regionResolver = new RegionResolver(REGION, "000000000000");+ service.createAutoScalingGroup(REGION,+ "test-asg",+ null,+ "lt-original",+ null,+ "1",+ 0,+ 3,+ 1,+ 300,+ List.of("us-east-1a"),+ List.of("subnet-12345678"),+ List.of(),+ List.of(),+ "EC2",+ 0,+ List.of("Default"),+ java.util.Map.of());+ }++ @Test+ void startInstanceRefreshStoresCompletedRefreshAndAppliesDesiredLaunchTemplate() {+ InstanceRefresh request = new InstanceRefresh();+ request.setStrategy("Rolling");+ request.setDesiredLaunchTemplateId("lt-updated");+ request.setDesiredLaunchTemplateVersion("2");+ request.setMinHealthyPercentage(90);+ request.setMaxHealthyPercentage(120);+ request.setInstanceWarmup(200);+ request.setSkipMatching(true);+ request.setAutoRollback(true);+ request.setCheckpointPercentages(List.of(50, 100));++ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", request);++ assertNotNull(refresh.getInstanceRefreshId());+ assertEquals("test-asg", refresh.getAutoScalingGroupName());+ assertEquals("Rolling", refresh.getStrategy());+ assertEquals("Successful", refresh.getStatus());+ assertEquals(100, refresh.getPercentageComplete());+ assertEquals(0, refresh.getInstancesToUpdate());+ assertEquals("lt-updated", refresh.getDesiredLaunchTemplateId());+ assertEquals("2", refresh.getDesiredLaunchTemplateVersion());+ assertEquals(90, refresh.getMinHealthyPercentage());+ assertEquals(120, refresh.getMaxHealthyPercentage());+ assertEquals(200, refresh.getInstanceWarmup());+ assertEquals(Boolean.TRUE, refresh.getSkipMatching());+ assertEquals(Boolean.TRUE, refresh.getAutoRollback());+ assertEquals(List.of(50, 100), refresh.getCheckpointPercentages());++ AutoScalingService.InstanceRefreshPage page =+ service.describeInstanceRefreshes(REGION, "test-asg", List.of(refresh.getInstanceRefreshId()), null, null);+ assertEquals(1, page.instanceRefreshes().size());+ assertEquals(refresh.getInstanceRefreshId(), page.instanceRefreshes().getFirst().getInstanceRefreshId());+ assertNull(page.nextToken());++ var group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ assertEquals("lt-updated", group.getLaunchTemplateId());+ assertEquals("2", group.getLaunchTemplateVersion());+ assertNull(group.getLaunchConfigurationName());+ }++ @Test+ void describeInstanceRefreshesPaginatesNewestFirst() {+ InstanceRefresh first = service.startInstanceRefresh(REGION, "test-asg", new InstanceRefresh());+ InstanceRefresh second = service.startInstanceRefresh(REGION, "test-asg", new InstanceRefresh());++ AutoScalingService.InstanceRefreshPage firstPage =+ service.describeInstanceRefreshes(REGION, "test-asg", List.of(), 1, null);+ assertEquals(1, firstPage.instanceRefreshes().size());+ assertEquals(second.getInstanceRefreshId(), firstPage.instanceRefreshes().getFirst().getInstanceRefreshId());+ assertEquals("1", firstPage.nextToken());++ AutoScalingService.InstanceRefreshPage secondPage =+ service.describeInstanceRefreshes(REGION, "test-asg", List.of(), 1, firstPage.nextToken());+ assertEquals(1, secondPage.instanceRefreshes().size());+ assertEquals(first.getInstanceRefreshId(), secondPage.instanceRefreshes().getFirst().getInstanceRefreshId());+ assertNull(secondPage.nextToken());+ }++ @Test+ void startInstanceRefreshMarksActiveInstancesForReplacement() {+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");++ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", new InstanceRefresh());++ assertEquals("InProgress", refresh.getStatus());+ assertEquals("Instance refresh in progress.", refresh.getStatusReason());+ assertEquals(0, refresh.getPercentageComplete());+ assertEquals(1, refresh.getInstancesToUpdate());+ assertNull(refresh.getEndTime());++ AsgInstance instance = service.describeAutoScalingGroups(REGION, List.of("test-asg"))+ .getFirst()+ .getInstances()+ .getFirst();+ assertEquals("Terminating", instance.getLifecycleState());+ }++ @Test+ void startInstanceRefreshRejectsSecondRefreshWhileFirstIsActive() {+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");+ service.startInstanceRefresh(REGION, "test-asg", new InstanceRefresh());++ AwsException error = assertThrows(AwsException.class,+ () -> service.startInstanceRefresh(REGION, "test-asg", new InstanceRefresh()));++ assertEquals("InstanceRefreshInProgress", error.getErrorCode());+ assertEquals(400, error.getHttpStatus());+ }++ @Test+ void startInstanceRefreshSkipMatchingLeavesMatchingInstancesInService() {+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-matching", "InService", "lt-original", "1");+ InstanceRefresh request = new InstanceRefresh();+ request.setSkipMatching(true);++ service.startInstanceRefresh(REGION, "test-asg", request);++ AsgInstance instance = service.describeAutoScalingGroups(REGION, List.of("test-asg"))+ .getFirst()+ .getInstances()+ .getFirst();+ assertEquals("InService", instance.getLifecycleState());+ }++ @Test+ void startInstanceRefreshWithLaunchTemplateAliasDoesNotSkipExistingInstances() {+ var group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ group.setLaunchTemplateVersion("$Latest");+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");+ InstanceRefresh request = new InstanceRefresh();+ request.setSkipMatching(true);++ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", request);++ assertEquals("InProgress", refresh.getStatus());+ assertEquals(1, refresh.getInstancesToUpdate());+ AsgInstance original = group.getInstances().getFirst();+ assertEquals("Terminating", original.getLifecycleState());++ group.getInstances().clear();+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-replacement", "InService", "lt-original", "2");+ service.completeInstanceRefreshIfSettled(REGION, "test-asg");++ InstanceRefresh completed = service.describeInstanceRefreshes(+ REGION, "test-asg", List.of(refresh.getInstanceRefreshId()), null, null)+ .instanceRefreshes()+ .getFirst();+ assertEquals("Successful", completed.getStatus());+ assertEquals(0, completed.getInstancesToUpdate());+ }++ @Test+ void startInstanceRefreshWithDefaultLaunchTemplateAliasDoesNotSkipExistingInstances() {+ var group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ group.setLaunchTemplateVersion("$Default");+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");+ InstanceRefresh request = new InstanceRefresh();+ request.setSkipMatching(true);++ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", request);++ assertEquals("InProgress", refresh.getStatus());+ assertEquals(1, refresh.getInstancesToUpdate());+ AsgInstance original = group.getInstances().getFirst();+ assertEquals("Terminating", original.getLifecycleState());++ group.getInstances().clear();+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-replacement", "InService", "lt-original", "2");+ service.completeInstanceRefreshIfSettled(REGION, "test-asg");++ InstanceRefresh completed = service.describeInstanceRefreshes(+ REGION, "test-asg", List.of(refresh.getInstanceRefreshId()), null, null)+ .instanceRefreshes()+ .getFirst();+ assertEquals("Successful", completed.getStatus());+ assertEquals(0, completed.getInstancesToUpdate());+ }++ @Test+ void startInstanceRefreshWithDefaultLaunchTemplateVersionDoesNotSkipExistingInstances() {+ var group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ group.setLaunchTemplateVersion(null);+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");+ InstanceRefresh request = new InstanceRefresh();+ request.setSkipMatching(true);++ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", request);++ assertEquals("InProgress", refresh.getStatus());+ assertEquals(1, refresh.getInstancesToUpdate());+ AsgInstance original = group.getInstances().getFirst();+ assertEquals("Terminating", original.getLifecycleState());+ }++ @Test+ void startInstanceRefreshWithBlankLaunchTemplateVersionDoesNotSkipExistingInstances() {+ var group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ group.setLaunchTemplateVersion("");+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");+ InstanceRefresh request = new InstanceRefresh();+ request.setSkipMatching(true);++ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", request);++ assertEquals("InProgress", refresh.getStatus());+ assertEquals(1, refresh.getInstancesToUpdate());+ AsgInstance original = group.getInstances().getFirst();+ assertEquals("Terminating", original.getLifecycleState());+ }++ @Test+ void completeInstanceRefreshMarksSettledReplacementSuccessful() {+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");+ InstanceRefresh request = new InstanceRefresh();+ request.setDesiredLaunchTemplateId("lt-updated");+ request.setDesiredLaunchTemplateVersion("2");+ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", request);+ var group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ group.getInstances().clear();+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-replacement", "InService", "lt-updated", "2");++ service.completeInstanceRefreshIfSettled(REGION, "test-asg");++ InstanceRefresh completed = service.describeInstanceRefreshes(+ REGION, "test-asg", List.of(refresh.getInstanceRefreshId()), null, null)+ .instanceRefreshes()+ .getFirst();+ assertEquals("Successful", completed.getStatus());+ assertEquals(100, completed.getPercentageComplete());+ assertEquals(0, completed.getInstancesToUpdate());+ assertNotNull(completed.getEndTime());+ }++ @Test+ void completeInstanceRefreshWaitsForReplacementCapacity() {+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-original", "InService", "lt-original", "1");+ InstanceRefresh refresh = service.startInstanceRefresh(REGION, "test-asg", new InstanceRefresh());+ var group = service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst();+ group.getInstances().clear();++ service.completeInstanceRefreshIfSettled(REGION, "test-asg");++ InstanceRefresh inProgress = service.describeInstanceRefreshes(+ REGION, "test-asg", List.of(refresh.getInstanceRefreshId()), null, null)+ .instanceRefreshes()+ .getFirst();+ assertEquals("InProgress", inProgress.getStatus());+ assertEquals(0, inProgress.getPercentageComplete());+ assertEquals(1, inProgress.getInstancesToUpdate());+ assertNull(inProgress.getEndTime());+ }++ @Test+ void deleteAutoScalingGroupWithoutForceRejectsActiveInstances() {+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-active", "InService", "lt-original", "1");++ AwsException error = assertThrows(AwsException.class,+ () -> service.deleteAutoScalingGroup(REGION, "test-asg", false));++ assertEquals("ResourceInUse", error.getErrorCode());+ }++ @Test+ void forceDeleteAutoScalingGroupTerminatesActiveEc2Instances() {+ Ec2Service ec2Service = mock(Ec2Service.class);+ service.ec2Service = ec2Service;+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-active", "InService", "lt-original", "1");+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-terminated", "Terminated", "lt-original", "1");++ service.deleteAutoScalingGroup(REGION, "test-asg", true);++ verify(ec2Service).terminateInstances(REGION, List.of("i-active"));+ assertTrue(service.describeAutoScalingGroups(REGION, List.of("test-asg")).isEmpty());+ }++ @Test+ void forceDeleteAutoScalingGroupIgnoresStaleEc2Membership() {+ Ec2Service ec2Service = mock(Ec2Service.class);+ service.ec2Service = ec2Service;+ AutoScalingGroupFixture.addInstance(service, REGION, "test-asg", "i-stale", "InService", "lt-original", "1");+ doThrow(new AwsException("InvalidInstanceID.NotFound", "Instance i-stale was not found.", 400))+ .when(ec2Service)+ .terminateInstances(REGION, List.of("i-stale"));++ service.deleteAutoScalingGroup(REGION, "test-asg", true);++ verify(ec2Service).terminateInstances(REGION, List.of("i-stale"));+ assertTrue(service.describeAutoScalingGroups(REGION, List.of("test-asg")).isEmpty());+ }++ private static final class AutoScalingGroupFixture {+ private static void addInstance(AutoScalingService service, String region, String name, String instanceId,+ String lifecycleState, String launchTemplateId, String launchTemplateVersion) {+ AsgInstance instance = new AsgInstance();+ instance.setInstanceId(instanceId);+ instance.setLifecycleState(lifecycleState);+ instance.setHealthStatus("Healthy");+ instance.setLaunchTemplateId(launchTemplateId);+ instance.setLaunchTemplateVersion(launchTemplateVersion);+ service.describeAutoScalingGroups(region, List.of(name))+ .getFirst()+ .getInstances()+ .add(instance);+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManagerTest.javanew file mode 100644index 0000000000..7f4dc2151d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManagerTest.java@@ -0,0 +1,436 @@+package io.github.hectorvent.floci.services.ec2;++import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.async.ResultCallback;+import com.github.dockerjava.api.command.CopyArchiveToContainerCmd;+import com.github.dockerjava.api.command.ExecCreateCmd;+import com.github.dockerjava.api.command.ExecCreateCmdResponse;+import com.github.dockerjava.api.command.ExecStartCmd;+import com.github.dockerjava.api.command.InspectContainerCmd;+import com.github.dockerjava.api.command.InspectContainerResponse;+import com.github.dockerjava.api.command.InspectExecCmd;+import com.github.dockerjava.api.command.InspectExecResponse;+import com.github.dockerjava.api.model.ContainerNetwork;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.NetworkSettings;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;+import io.github.hectorvent.floci.core.common.docker.ContainerSpec;+import io.github.hectorvent.floci.core.common.docker.DockerHostResolver;+import io.github.hectorvent.floci.core.common.docker.PortAllocator;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.ec2.model.InstanceNetworkInterface;+import org.junit.jupiter.api.Test;++import java.io.InputStream;+import java.time.Duration;+import java.util.Arrays;+import java.util.List;+import java.util.Map;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicReference;+import java.util.function.BooleanSupplier;++import static org.junit.jupiter.api.Assertions.assertArrayEquals;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyInt;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Answers.RETURNS_SELF;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.times;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;+import static org.mockito.Mockito.withSettings;++class Ec2ContainerManagerTest {++ @org.junit.jupiter.api.AfterEach+ void resetBridgeIpPolling() {+ Ec2ContainerManager.containerBridgeIpAttempts = 30;+ Ec2ContainerManager.containerBridgeIpPollMillis = 500;+ }++ @Test+ void exposeReachablePrivateAddressUpdatesInstanceAndAttachedNetworkInterfaces() {+ Instance instance = new Instance();+ instance.setPrivateIpAddress("10.82.32.10");+ instance.setPrivateDnsName("ip-10-82-32-10.ec2.internal");++ InstanceNetworkInterface networkInterface = new InstanceNetworkInterface();+ networkInterface.setPrivateIpAddress("10.82.32.10");+ networkInterface.setPrivateDnsName("ip-10-82-32-10.ec2.internal");+ instance.setNetworkInterfaces(List.of(networkInterface));++ Ec2ContainerManager.exposeReachablePrivateAddress(instance, "192.168.215.21");++ assertEquals("192.168.215.21", instance.getPrivateIpAddress());+ assertEquals("ip-192-168-215-21.ec2.internal", instance.getPrivateDnsName());+ assertEquals("192.168.215.21", networkInterface.getPrivateIpAddress());+ assertEquals("ip-192-168-215-21.ec2.internal", networkInterface.getPrivateDnsName());+ }++ @Test+ void restoreMetadataRegistrationRegistersRunningPersistedContainer() {+ ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);+ when(lifecycleManager.isContainerRunning("container-1")).thenReturn(true);++ DockerClient dockerClient = mock(DockerClient.class);+ InspectContainerCmd inspect = mock(InspectContainerCmd.class);+ InspectContainerResponse response = inspectResponse("192.168.215.42");+ when(dockerClient.inspectContainerCmd("container-1")).thenReturn(inspect);+ when(inspect.exec()).thenReturn(response);++ Ec2MetadataServer metadataServer = mock(Ec2MetadataServer.class);+ Ec2ContainerManager manager = new Ec2ContainerManager(+ mock(ContainerBuilder.class),+ lifecycleManager,+ mock(ContainerLogStreamer.class),+ mock(ContainerDetector.class),+ mock(DockerHostResolver.class),+ dockerClient,+ mock(PortAllocator.class),+ mock(EmulatorConfig.class),+ metadataServer);++ Instance instance = new Instance();+ instance.setInstanceId("i-restored");+ instance.setDockerContainerId("container-1");+ instance.setContainerBridgeIp("192.168.215.7");++ assertTrue(manager.restoreMetadataRegistration(instance));++ assertEquals("192.168.215.42", instance.getContainerBridgeIp());+ assertEquals("192.168.215.42", instance.getPrivateIpAddress());+ verify(metadataServer).unregisterContainer("192.168.215.7", instance);+ verify(metadataServer).registerContainer("192.168.215.42", "i-restored", instance);+ }++ @Test+ void userDataExecutionCommandRunsScriptDirectlySoShebangIsHonored() {+ assertArrayEquals(new String[]{"/tmp/user-data.sh"}, Ec2ContainerManager.userDataExecutionCommand());+ }++ @Test+ void userDataShellScriptsPreservesRawShellScript() {+ String script = "#!/bin/bash\nset -euo pipefail\necho ready\n";++ assertEquals(List.of(script), Ec2ContainerManager.userDataShellScripts(script));+ }++ @Test+ void userDataShellScriptsExtractsMimeShellscriptPartsInOrder() {+ String userData = """+ Content-Type: multipart/mixed; boundary="==SAMPLE-CLOUD-INIT=="+ MIME-Version: 1.0++ --==SAMPLE-CLOUD-INIT==+ Content-Type: text/cloud-config; charset="us-ascii"++ #cloud-config++ --==SAMPLE-CLOUD-INIT==+ Content-Type: text/x-shellscript; charset="us-ascii"++ #!/bin/bash+ echo first++ --==SAMPLE-CLOUD-INIT==+ Content-Type: text/x-shellscript++ #!/bin/sh+ echo second++ --==SAMPLE-CLOUD-INIT==--+ """;++ assertEquals(+ List.of(+ "#!/bin/bash\necho first\n",+ "#!/bin/sh\necho second\n"),+ Ec2ContainerManager.userDataShellScripts(userData));+ }++ @Test+ void userDataShellScriptsIgnoresCloudConfigWithoutShellscript() {+ String userData = """+ Content-Type: multipart/mixed; boundary=cloudinit+ MIME-Version: 1.0++ --cloudinit+ Content-Type: text/cloud-config++ #cloud-config++ --cloudinit--+ """;++ assertTrue(Ec2ContainerManager.userDataShellScripts(userData).isEmpty());+ }++ @Test+ void metadataProxyInstallCommandInstallsLinkLocalProxyDependencies() {+ String[] command = Ec2ContainerManager.metadataProxyInstallCommand();++ assertEquals("sh", command[0]);+ assertTrue(command[2].contains("iproute2"));+ assertTrue(command[2].contains("socat"));+ assertTrue(command[2].contains("curl"));+ }++ @Test+ void metadataProxyStartCommandBindsAwsLinkLocalMetadataAddress() {+ String[] command = Ec2ContainerManager.metadataProxyStartCommand("floci", 9169);++ assertEquals("sh", command[0]);+ assertTrue(command[2].contains("169.254.169.254/32"));+ assertTrue(command[2].contains("TCP-LISTEN:80,bind=169.254.169.254"));+ assertTrue(command[2].contains("TCP:floci:9169"));+ assertTrue(command[2].contains("http://169.254.169.254/latest/meta-data/instance-id"));+ }++ @Test+ void localAwsEnvironmentProvidesCliCredentialsAndFlociEndpoint() {+ assertEquals(+ java.util.List.of(+ "AWS_EC2_METADATA_SERVICE_ENDPOINT=http://floci:9169",+ "AWS_ENDPOINT_URL=http://floci:4566",+ "AWS_DEFAULT_REGION=us-west-2",+ "AWS_REGION=us-west-2",+ "AWS_ACCESS_KEY_ID=test",+ "AWS_SECRET_ACCESS_KEY=test",+ "AWS_SESSION_TOKEN=test-session-token"),+ Ec2ContainerManager.localAwsEnvironment(+ "us-west-2",+ "http://floci:4566",+ "http://floci:9169"));+ }++ @Test+ void preferredMetadataSourceIpUsesConfiguredNetworkBeforeBridge() {+ ContainerNetwork bridge = new ContainerNetwork();+ bridge.withIpv4Address("172.17.0.8");+ ContainerNetwork floci = new ContainerNetwork();+ floci.withIpv4Address("192.168.215.10");++ assertEquals(+ "192.168.215.10",+ Ec2ContainerManager.preferredMetadataSourceIp(Map.of(+ "bridge", bridge,+ "custom-floci-network", floci)).orElseThrow());+ }++ @Test+ void preferredMetadataSourceIpFallsBackToBridge() {+ ContainerNetwork bridge = new ContainerNetwork();+ bridge.withIpv4Address("172.17.0.8");++ assertEquals(+ "172.17.0.8",+ Ec2ContainerManager.preferredMetadataSourceIp(Map.of("bridge", bridge)).orElseThrow());+ }++ @Test+ void preferredMetadataSourceIpIsEmptyWithoutUsableAddress() {+ ContainerNetwork bridge = new ContainerNetwork();++ assertTrue(Ec2ContainerManager.preferredMetadataSourceIp(Map.of("bridge", bridge)).isEmpty());+ }++ @Test+ void launchWaitsForContainerBridgeIpBeforeRegisteringImds() throws Exception {+ Ec2ContainerManager.containerBridgeIpAttempts = 3;+ Ec2ContainerManager.containerBridgeIpPollMillis = 1;+ LaunchHarness harness = launchHarness();+ InspectContainerCmd inspect = mock(InspectContainerCmd.class);+ InspectContainerResponse noIp = inspectResponse(null);+ InspectContainerResponse withIp = inspectResponse("172.18.0.9");+ when(harness.dockerClient.inspectContainerCmd("container-1")).thenReturn(inspect);+ when(inspect.exec()).thenReturn(noIp).thenReturn(withIp);+ harness.stubSuccessfulExecs(new CountDownLatch(0), new CountDownLatch(0));++ Instance instance = instance("i-waitip");++ harness.manager.launch(instance, "ubuntu:24.04", null, "us-west-2");++ awaitUntil(() -> "running".equals(instance.getState().getName()), Duration.ofSeconds(2));+ assertEquals("container-1", instance.getDockerContainerId());+ assertEquals("172.18.0.9", instance.getContainerBridgeIp());+ assertEquals("172.18.0.9", instance.getPrivateIpAddress());+ verify(inspect, times(2)).exec();+ verify(harness.metadataServer).registerContainer("172.18.0.9", "i-waitip", instance);+ }++ @Test+ void launchTerminatesWhenContainerBridgeIpNeverAppears() throws Exception {+ Ec2ContainerManager.containerBridgeIpAttempts = 2;+ Ec2ContainerManager.containerBridgeIpPollMillis = 1;+ LaunchHarness harness = launchHarness();+ InspectContainerCmd inspect = mock(InspectContainerCmd.class);+ InspectContainerResponse noIp = inspectResponse(null);+ when(harness.dockerClient.inspectContainerCmd("container-1")).thenReturn(inspect);+ when(inspect.exec()).thenReturn(noIp);++ Instance instance = instance("i-noip");++ harness.manager.launch(instance, "ubuntu:24.04", null, "us-west-2");++ awaitUntil(() -> "terminated".equals(instance.getState().getName()), Duration.ofSeconds(2));+ assertEquals("container-1", instance.getDockerContainerId());+ verify(harness.metadataServer, never()).registerContainer(anyString(), anyString(), any());+ }++ @Test+ void launchMarksInstanceRunningBeforeUserDataCompletes() throws Exception {+ Ec2ContainerManager.containerBridgeIpAttempts = 2;+ Ec2ContainerManager.containerBridgeIpPollMillis = 1;+ LaunchHarness harness = launchHarness();+ InspectContainerCmd inspect = mock(InspectContainerCmd.class);+ InspectContainerResponse withIp = inspectResponse("172.18.0.10");+ when(harness.dockerClient.inspectContainerCmd("container-1")).thenReturn(inspect);+ when(inspect.exec()).thenReturn(withIp);+ CountDownLatch userDataStarted = new CountDownLatch(1);+ CountDownLatch finishUserData = new CountDownLatch(1);+ harness.stubSuccessfulExecs(userDataStarted, finishUserData);+ Instance instance = instance("i-userdata");+ instance.setUserData("#!/bin/sh\necho ready\n");++ harness.manager.launch(instance, "ubuntu:24.04", null, "us-west-2");++ assertTrue(userDataStarted.await(2, TimeUnit.SECONDS), "user data should start");+ assertEquals("running", instance.getState().getName());+ assertFalse(finishUserData.await(10, TimeUnit.MILLISECONDS), "user data should still be blocked");+ finishUserData.countDown();+ awaitUntil(() -> "running".equals(instance.getState().getName()), Duration.ofSeconds(2));+ }++ private static LaunchHarness launchHarness() {+ ContainerBuilder containerBuilder = mock(ContainerBuilder.class);+ ContainerBuilder.Builder builder = mock(ContainerBuilder.Builder.class, withSettings().defaultAnswer(RETURNS_SELF));+ when(containerBuilder.newContainer(anyString())).thenReturn(builder);+ when(builder.build()).thenReturn(new ContainerSpec("ubuntu:24.04"));++ ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);+ when(lifecycleManager.create(any(ContainerSpec.class))).thenReturn("container-1");+ when(lifecycleManager.isContainerRunning("container-1")).thenReturn(true);++ DockerHostResolver dockerHostResolver = mock(DockerHostResolver.class);+ when(dockerHostResolver.resolve()).thenReturn("floci");+ PortAllocator portAllocator = mock(PortAllocator.class);+ when(portAllocator.allocate(anyInt(), anyInt())).thenReturn(2201);++ EmulatorConfig config = mock(EmulatorConfig.class);+ EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);+ EmulatorConfig.Ec2ServiceConfig ec2 = mock(EmulatorConfig.Ec2ServiceConfig.class);+ when(config.services()).thenReturn(services);+ when(services.ec2()).thenReturn(ec2);+ when(ec2.sshPortRangeStart()).thenReturn(2200);+ when(ec2.sshPortRangeEnd()).thenReturn(2299);+ when(ec2.imdsPort()).thenReturn(9169);++ DockerClient dockerClient = mock(DockerClient.class);+ Ec2MetadataServer metadataServer = mock(Ec2MetadataServer.class);+ Ec2ContainerManager manager = new Ec2ContainerManager(+ containerBuilder,+ lifecycleManager,+ mock(ContainerLogStreamer.class),+ mock(ContainerDetector.class),+ dockerHostResolver,+ dockerClient,+ portAllocator,+ config,+ metadataServer);+ return new LaunchHarness(manager, dockerClient, metadataServer);+ }++ private static Instance instance(String instanceId) {+ Instance instance = new Instance();+ instance.setInstanceId(instanceId);+ return instance;+ }++ private static InspectContainerResponse inspectResponse(String ipAddress) {+ InspectContainerResponse inspect = mock(InspectContainerResponse.class);+ NetworkSettings networkSettings = mock(NetworkSettings.class);+ when(inspect.getNetworkSettings()).thenReturn(networkSettings);+ if (ipAddress != null) {+ ContainerNetwork bridge = new ContainerNetwork().withIpv4Address(ipAddress);+ when(networkSettings.getNetworks()).thenReturn(Map.of("bridge", bridge));+ }+ return inspect;+ }++ private static void awaitUntil(BooleanSupplier condition, Duration timeout) throws InterruptedException {+ long deadline = System.nanoTime() + timeout.toNanos();+ while (System.nanoTime() < deadline) {+ if (condition.getAsBoolean()) {+ return;+ }+ Thread.sleep(10);+ }+ assertTrue(condition.getAsBoolean(), "condition was not met before timeout");+ }++ private record LaunchHarness(Ec2ContainerManager manager,+ DockerClient dockerClient,+ Ec2MetadataServer metadataServer) {+ void stubSuccessfulExecs(CountDownLatch userDataStarted, CountDownLatch finishUserData) throws Exception {+ AtomicReference<String[]> currentCommand = new AtomicReference<>();+ ExecCreateCmd execCreate = mock(ExecCreateCmd.class, withSettings().defaultAnswer(RETURNS_SELF));+ ExecCreateCmdResponse metadataExec = mock(ExecCreateCmdResponse.class);+ ExecCreateCmdResponse userDataExec = mock(ExecCreateCmdResponse.class);+ when(metadataExec.getId()).thenReturn("metadata-exec");+ when(userDataExec.getId()).thenReturn("userdata-exec");+ when(dockerClient.execCreateCmd("container-1")).thenReturn(execCreate);+ when(execCreate.withCmd(any(String[].class))).thenAnswer(invocation -> {+ Object[] args = invocation.getArguments();+ if (args.length == 1 && args[0] instanceof String[] command) {+ currentCommand.set(command);+ } else {+ currentCommand.set(Arrays.copyOf(args, args.length, String[].class));+ }+ return execCreate;+ });+ when(execCreate.exec()).thenAnswer(invocation -> {+ String[] command = currentCommand.get();+ if (command != null && command.length == 1 && "/tmp/user-data.sh".equals(command[0])) {+ return userDataExec;+ }+ return metadataExec;+ });++ when(dockerClient.execStartCmd(anyString())).thenAnswer(invocation -> {+ String execId = invocation.getArgument(0);+ ExecStartCmd execStart = mock(ExecStartCmd.class);+ when(execStart.exec(any())).thenAnswer(startInvocation -> {+ @SuppressWarnings("unchecked")+ ResultCallback<Frame> callback = startInvocation.getArgument(0);+ if ("userdata-exec".equals(execId)) {+ userDataStarted.countDown();+ finishUserData.await(2, TimeUnit.SECONDS);+ }+ callback.onComplete();+ return callback;+ });+ return execStart;+ });++ InspectExecCmd inspectExec = mock(InspectExecCmd.class);+ InspectExecResponse inspectExecResponse = mock(InspectExecResponse.class);+ when(inspectExecResponse.getExitCodeLong()).thenReturn(0L);+ when(inspectExec.exec()).thenReturn(inspectExecResponse);+ when(dockerClient.inspectExecCmd(anyString())).thenReturn(inspectExec);++ CopyArchiveToContainerCmd copy = mock(CopyArchiveToContainerCmd.class, withSettings().defaultAnswer(RETURNS_SELF));+ when(dockerClient.copyArchiveToContainerCmd("container-1")).thenReturn(copy);+ when(copy.withTarInputStream(any(InputStream.class))).thenReturn(copy);+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.javaindex ba08397292..064a9c3fb2 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java@@ -646,6 +646,11 @@ class Ec2IntegrationTest {.formParam("LaunchTemplateData.KeyName", "test-key").formParam("LaunchTemplateData.SecurityGroupId.1", securityGroupId).formParam("LaunchTemplateData.UserData", gzipBase64("#!/bin/sh\necho launch-template\n"))+ .formParam("LaunchTemplateData.TagSpecification.1.ResourceType", "instance")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.1.Key", "example:ClusterId")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.1.Value", "sample-template")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.2.Key", "example:NodeType")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.2.Value", "COORDINATOR").formParam("TagSpecification.1.ResourceType", "launch-template").formParam("TagSpecification.1.Tag.1.Key", "Name").formParam("TagSpecification.1.Tag.1.Value", "sample-template")@@ -696,7 +701,13 @@ class Ec2IntegrationTest {.body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.instanceType",equalTo("t3.micro")).body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.userData",- equalTo("#!/bin/sh\necho launch-template\n"));+ equalTo("#!/bin/sh\necho launch-template\n"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.tagSpecificationSet.item.resourceType",+ equalTo("instance"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.tagSpecificationSet.item.tagSet.item.find { it.key == 'example:ClusterId' }.value",+ equalTo("sample-template"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.tagSpecificationSet.item.tagSet.item.find { it.key == 'example:NodeType' }.value",+ equalTo("COORDINATOR"));}@Test@@ -713,6 +724,9 @@ class Ec2IntegrationTest {.formParam("LaunchTemplateData.KeyName", "test-key").formParam("LaunchTemplateData.SecurityGroupId.1", securityGroupId).formParam("LaunchTemplateData.UserData", gzipBase64("#!/bin/sh\necho launch-template-version\n"))+ .formParam("LaunchTemplateData.TagSpecification.1.ResourceType", "instance")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.1.Key", "example:NodeType")+ .formParam("LaunchTemplateData.TagSpecification.1.Tag.1.Value", "WORKER").header("Authorization", AUTH_HEADER).when().post("/")@@ -727,7 +741,9 @@ class Ec2IntegrationTest {.body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.launchTemplateData.instanceType",equalTo("t3.small")).body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.launchTemplateData.userData",- equalTo("#!/bin/sh\necho launch-template-version\n"));+ equalTo("#!/bin/sh\necho launch-template-version\n"))+ .body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.launchTemplateData.tagSpecificationSet.item.tagSet.item.find { it.key == 'example:NodeType' }.value",+ equalTo("WORKER"));given().formParam("Action", "DescribeLaunchTemplateVersions")@@ -743,7 +759,11 @@ class Ec2IntegrationTest {.body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.defaultVersion",equalTo("true")).body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.instanceType",- equalTo("t3.micro"));+ equalTo("t3.micro"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.userData",+ equalTo("#!/bin/sh\necho launch-template\n"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.tagSpecificationSet.item.tagSet.item.find { it.key == 'example:NodeType' }.value",+ equalTo("COORDINATOR"));}@Test@@ -1246,6 +1266,8 @@ class Ec2IntegrationTest {.formParam("Action", "DescribeInstances").formParam("Filter.1.Name", "instance-state-name").formParam("Filter.1.Value.1", "running")+ .formParam("Filter.2.Name", "instance-id")+ .formParam("Filter.2.Value.1", instanceId).header("Authorization", AUTH_HEADER).when().post("/")@@ -1337,9 +1359,10 @@ class Ec2IntegrationTest {@Test@Order(79)void describeNetworkInterfacesBeforeRun() {- // Before any instances exist, the set should be emptygiven().formParam("Action", "DescribeNetworkInterfaces")+ .formParam("Filter.1.Name", "attachment.instance-id")+ .formParam("Filter.1.Value.1", "i-00000000000000000").header("Authorization", AUTH_HEADER).when().post("/")@@ -1354,13 +1377,15 @@ class Ec2IntegrationTest {void describeNetworkInterfacesAfterRun() {networkInterfaceId = given().formParam("Action", "DescribeNetworkInterfaces")+ .formParam("Filter.1.Name", "attachment.instance-id")+ .formParam("Filter.1.Value.1", instanceId).header("Authorization", AUTH_HEADER).when().post("/").then().statusCode(200).contentType("application/xml")- .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.size()", greaterThanOrEqualTo(1))+ .body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.size()", equalTo(1)).body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item[0].networkInterfaceId",startsWith("eni-")).body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item[0].vpcId", notNullValue())@@ -1373,7 +1398,7 @@ class Ec2IntegrationTest {.body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item[0].attachment.deviceIndex",equalTo("0")).body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item[0].attachment.instanceId",- notNullValue())+ equalTo(instanceId)).body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item[0].groupSet.item.size()",greaterThanOrEqualTo(1)).extract().path("DescribeNetworkInterfacesResponse.networkInterfaceSet.item[0].networkInterfaceId");@@ -1576,13 +1601,15 @@ class Ec2IntegrationTest {.formParam("Action", "DescribeNetworkInterfaces").formParam("Filter.1.Name", "status").formParam("Filter.1.Value.1", "in-use")+ .formParam("Filter.2.Name", "attachment.instance-id")+ .formParam("Filter.2.Value.1", instanceId).header("Authorization", AUTH_HEADER).when().post("/").then().statusCode(200).body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item.size()",- greaterThanOrEqualTo(1))+ equalTo(1)).body("DescribeNetworkInterfacesResponse.networkInterfaceSet.item[0].status",equalTo("in-use"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServerTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServerTest.javanew file mode 100644index 0000000000..951c197cff--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServerTest.java@@ -0,0 +1,67 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.ec2.model.Tag;+import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++class Ec2MetadataServerTest {++ @Test+ void instanceMetadataListsTagKeys() {+ Instance instance = new Instance();+ instance.setTags(List.of(+ new Tag("Environment", "dev"),+ new Tag("Service", "orders")));++ assertEquals("Environment\nService", Ec2MetadataServer.instanceTagKeys(instance));+ }++ @Test+ void instanceMetadataReturnsTagValue() {+ Instance instance = new Instance();+ instance.setTags(List.of(+ new Tag("Environment", "dev"),+ new Tag("Service", "orders")));++ assertEquals("orders", Ec2MetadataServer.instanceTagValue(instance, "Service").orElseThrow());+ }++ @Test+ void instanceMetadataReturnsEmptyValueForEmptyTag() {+ Instance instance = new Instance();+ instance.setTags(List.of(new Tag("Owner", null)));++ assertTrue(Ec2MetadataServer.instanceTagValue(instance, "Owner").isPresent());+ assertEquals("", Ec2MetadataServer.instanceTagValue(instance, "Owner").orElseThrow());+ }++ @Test+ void instanceMetadataReturnsMissingForUnknownTag() {+ Instance instance = new Instance();+ instance.setTags(List.of(new Tag("Environment", "dev")));++ assertTrue(Ec2MetadataServer.instanceTagValue(instance, "Missing").isEmpty());+ }++ @Test+ void staleContainerUnregisterDoesNotRemoveCurrentRegistration() {+ Ec2MetadataServer server = new Ec2MetadataServer(null, null);+ Instance oldInstance = new Instance();+ oldInstance.setInstanceId("i-old");+ Instance currentInstance = new Instance();+ currentInstance.setInstanceId("i-current");++ server.registerContainer("192.168.215.7", oldInstance.getInstanceId(), oldInstance);+ server.registerContainer("192.168.215.7", currentInstance.getInstanceId(), currentInstance);+ server.unregisterContainer("192.168.215.7", oldInstance);++ assertEquals(+ currentInstance,+ server.registeredContainer("192.168.215.7").orElseThrow());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.javaindex 2c3a4db48f..53cc58b538 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.java@@ -33,6 +33,7 @@ class Ec2Phase2IntegrationTest {private static String instanceWithUserData;private static String instanceWithProfile;+ private static String instanceWithProfileName;private static String instanceForTerminate;private static String importedKeyName = "phase2-imported-key";@@ -119,6 +120,46 @@ class Ec2Phase2IntegrationTest {equalTo("running"));}+ @Test+ @Order(12)+ void runInstancesWithIamInstanceProfileName() {+ String profileName = "my-app-profile";++ instanceWithProfileName = given()+ .formParam("Action", "RunInstances")+ .formParam("ImageId", "ami-ubuntu2204")+ .formParam("InstanceType", "t3.micro")+ .formParam("MinCount", "1")+ .formParam("MaxCount", "1")+ .formParam("IamInstanceProfile.Name", profileName)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("RunInstancesResponse.instancesSet.item.instanceId", startsWith("i-"))+ .body("RunInstancesResponse.instancesSet.item.iamInstanceProfile.arn",+ equalTo("arn:aws:iam::000000000000:instance-profile/" + profileName))+ .extract().path("RunInstancesResponse.instancesSet.item.instanceId");+ }++ @Test+ @Order(13)+ void describeInstanceWithProfileName() {+ given()+ .formParam("Action", "DescribeInstances")+ .formParam("InstanceId.1", instanceWithProfileName)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.instanceId",+ equalTo(instanceWithProfileName))+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.iamInstanceProfile.arn",+ equalTo("arn:aws:iam::000000000000:instance-profile/my-app-profile"));+ }+// ─── SSH key import ────────────────────────────────────────────────────────@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.javanew file mode 100644index 0000000000..e74ab2420c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java@@ -0,0 +1,86 @@+package io.github.hectorvent.floci.services.ec2;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+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.model.LaunchTemplate;+import io.github.hectorvent.floci.services.ec2.model.Reservation;+import io.github.hectorvent.floci.services.ec2.model.Tag;+import org.junit.jupiter.api.Test;++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.assertTrue;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verifyNoInteractions;+import static org.mockito.Mockito.when;++class Ec2ServiceTest {++ @Test+ void mockModeTreatsExistingNonTerminatedInstanceAsRunningContainer() {+ Ec2ContainerManager containerManager = mock(Ec2ContainerManager.class);+ Ec2Service service = new Ec2Service(mockConfig(true), containerManager,+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new InMemoryStorageFactory());+ Reservation reservation = service.runInstances("us-east-1", "ami-1234567890abcdef0", "t3.micro",+ 1, 1, null, List.of(), null, null, List.of(), null, null);+ String instanceId = reservation.getInstances().getFirst().getInstanceId();++ assertTrue(service.isInstanceContainerRunning(instanceId));+ service.terminateInstances("us-east-1", List.of(instanceId));+ assertFalse(service.isInstanceContainerRunning(instanceId));+ verifyNoInteractions(containerManager);+ }++ @Test+ void launchTemplateVersionInheritsOmittedFieldsFromRequestedSourceVersion() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new InMemoryStorageFactory());+ LaunchTemplate template = service.createLaunchTemplate("us-east-1", "app-template",+ "ami-source", "t3.micro", "app-key", List.of("sg-source"),+ "source-user-data", List.of(), List.of(new Tag("Role", "source")));++ service.createLaunchTemplateVersion("us-east-1", template.getLaunchTemplateId(), null,+ "1", null, "t3.small", null, List.of(), null, List.of());++ LaunchTemplate version = service.describeLaunchTemplateVersions(+ "us-east-1", template.getLaunchTemplateId(), null, List.of("2")).getFirst();+ assertEquals("ami-source", version.getImageId());+ assertEquals("t3.small", version.getInstanceType());+ assertEquals("app-key", version.getKeyName());+ assertEquals(List.of("sg-source"), version.getSecurityGroupIds());+ assertEquals("source-user-data", version.getUserData());+ assertEquals("2", version.getLatestVersionNumber());+ assertEquals(1, version.getInstanceTags().size());+ assertEquals("Role", version.getInstanceTags().getFirst().getKey());+ assertEquals("source", version.getInstanceTags().getFirst().getValue());+ }++ private static EmulatorConfig mockConfig(boolean ec2Mock) {+ EmulatorConfig config = mock(EmulatorConfig.class);+ EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);+ EmulatorConfig.Ec2ServiceConfig ec2 = mock(EmulatorConfig.Ec2ServiceConfig.class);+ when(config.defaultAccountId()).thenReturn("000000000000");+ when(config.services()).thenReturn(services);+ when(services.ec2()).thenReturn(ec2);+ when(ec2.mock()).thenReturn(ec2Mock);+ return config;+ }++ private static final class InMemoryStorageFactory extends StorageFactory {+ private InMemoryStorageFactory() {+ super(null, null);+ }++ @Override+ public <V> StorageBackend<String, V> create(String serviceName, String fileName,+ TypeReference<Map<String, V>> typeReference) {+ return new InMemoryStorage<>();+ }+ }+}