Light, fluffy, and always free - The AWS Local Emulator alternative
fix(autoscaling): round-trip InstanceMaintenancePolicy, AvailabilityZoneDistribution, CapacityReservationSpecification, ServiceLinkedRoleARN, WeightedCapacity and EnabledMetrics (#5513)
lex00991bf3ab9e71
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AutoScalingTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AutoScalingTest.javaindex 3c7a274136..8b294a0a6c 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AutoScalingTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/AutoScalingTest.java@@ -7,10 +7,22 @@ import org.junit.jupiter.api.Test;import software.amazon.awssdk.services.autoscaling.AutoScalingClient;import software.amazon.awssdk.services.autoscaling.model.AttachInstancesRequest;import software.amazon.awssdk.services.autoscaling.model.AutoScalingException;+import software.amazon.awssdk.services.autoscaling.model.AutoScalingGroup;+import software.amazon.awssdk.services.autoscaling.model.AvailabilityZoneDistribution;+import software.amazon.awssdk.services.autoscaling.model.CapacityReservationSpecification;+import software.amazon.awssdk.services.autoscaling.model.CapacityReservationTarget;import software.amazon.awssdk.services.autoscaling.model.CreateAutoScalingGroupRequest;import software.amazon.awssdk.services.autoscaling.model.CreateLaunchConfigurationRequest;+import software.amazon.awssdk.services.autoscaling.model.DeleteAutoScalingGroupRequest;import software.amazon.awssdk.services.autoscaling.model.DesiredConfiguration;+import software.amazon.awssdk.services.autoscaling.model.DisableMetricsCollectionRequest;+import software.amazon.awssdk.services.autoscaling.model.EnableMetricsCollectionRequest;+import software.amazon.awssdk.services.autoscaling.model.EnabledMetric;+import software.amazon.awssdk.services.autoscaling.model.InstanceMaintenancePolicy;+import software.amazon.awssdk.services.autoscaling.model.LaunchTemplate;+import software.amazon.awssdk.services.autoscaling.model.LaunchTemplateOverrides;import software.amazon.awssdk.services.autoscaling.model.LaunchTemplateSpecification;+import software.amazon.awssdk.services.autoscaling.model.MixedInstancesPolicy;import software.amazon.awssdk.services.autoscaling.model.StartInstanceRefreshRequest;import software.amazon.awssdk.services.autoscaling.model.UpdateAutoScalingGroupRequest;import software.amazon.awssdk.services.ec2.Ec2Client;@@ -20,6 +32,7 @@ import software.amazon.awssdk.services.ec2.model.RequestLaunchTemplateData;import static org.assertj.core.api.Assertions.assertThat;import static org.assertj.core.api.Assertions.assertThatThrownBy;+import static org.assertj.core.api.Assertions.tuple;@DisplayName("Auto Scaling")class AutoScalingTest {@@ -204,4 +217,107 @@ class AutoScalingTest {"SDK Attempt Count: 1");});}++ @Test+ @DisplayName("DescribeAutoScalingGroups returns the optional structures and EnabledMetrics a client set")+ void optionalStructuresAndEnabledMetricsRoundTripThroughTheSdk() {+ String launchTemplateName = TestFixtures.uniqueName("sdk-optional-structures");+ String autoScalingGroupName = TestFixtures.uniqueName("sdk-optional-structures-asg");+ String roleArn = "arn:aws:iam::000000000000:role/aws-service-role/autoscaling.amazonaws.com/"+ + "AWSServiceRoleForAutoScaling_sdk";++ ec2.createLaunchTemplate(CreateLaunchTemplateRequest.builder()+ .launchTemplateName(launchTemplateName)+ .launchTemplateData(RequestLaunchTemplateData.builder()+ .imageId("ami-12345678")+ .instanceType("t3.micro")+ .build())+ .build());+ autoScaling.createAutoScalingGroup(CreateAutoScalingGroupRequest.builder()+ .autoScalingGroupName(autoScalingGroupName)+ .mixedInstancesPolicy(MixedInstancesPolicy.builder()+ .launchTemplate(LaunchTemplate.builder()+ .launchTemplateSpecification(LaunchTemplateSpecification.builder()+ .launchTemplateName(launchTemplateName)+ .version("1")+ .build())+ .overrides(+ LaunchTemplateOverrides.builder()+ .instanceType("t3.micro").weightedCapacity("1").build(),+ LaunchTemplateOverrides.builder()+ .instanceType("t3.large").weightedCapacity("4").build())+ .build())+ .build())+ .minSize(0)+ .maxSize(4)+ .desiredCapacity(0)+ .availabilityZones("us-east-1a")+ .serviceLinkedRoleARN(roleArn)+ .instanceMaintenancePolicy(InstanceMaintenancePolicy.builder()+ .minHealthyPercentage(90)+ .maxHealthyPercentage(120)+ .build())+ .availabilityZoneDistribution(AvailabilityZoneDistribution.builder()+ .capacityDistributionStrategy("balanced-only")+ .build())+ .capacityReservationSpecification(CapacityReservationSpecification.builder()+ .capacityReservationPreference("capacity-reservations-first")+ .capacityReservationTarget(CapacityReservationTarget.builder()+ .capacityReservationIds("cr-0123456789abcdef0")+ .build())+ .build())+ .build());+ try {+ autoScaling.enableMetricsCollection(EnableMetricsCollectionRequest.builder()+ .autoScalingGroupName(autoScalingGroupName)+ .granularity("1Minute")+ .metrics("GroupMinSize", "GroupMaxSize")+ .build());++ AutoScalingGroup group = describe(autoScalingGroupName);+ assertThat(group.serviceLinkedRoleARN()).isEqualTo(roleArn);+ assertThat(group.instanceMaintenancePolicy().minHealthyPercentage()).isEqualTo(90);+ assertThat(group.instanceMaintenancePolicy().maxHealthyPercentage()).isEqualTo(120);+ assertThat(group.availabilityZoneDistribution().capacityDistributionStrategyAsString())+ .isEqualTo("balanced-only");+ assertThat(group.capacityReservationSpecification().capacityReservationPreferenceAsString())+ .isEqualTo("capacity-reservations-first");+ assertThat(group.capacityReservationSpecification().capacityReservationTarget()+ .capacityReservationIds()).containsExactly("cr-0123456789abcdef0");+ assertThat(group.mixedInstancesPolicy().launchTemplate().overrides())+ .extracting(LaunchTemplateOverrides::weightedCapacity)+ .containsExactly("1", "4");+ assertThat(group.enabledMetrics())+ .extracting(EnabledMetric::metric, EnabledMetric::granularity)+ .containsExactly(+ tuple("GroupMinSize", "1Minute"),+ tuple("GroupMaxSize", "1Minute"));++ autoScaling.updateAutoScalingGroup(UpdateAutoScalingGroupRequest.builder()+ .autoScalingGroupName(autoScalingGroupName)+ .instanceMaintenancePolicy(InstanceMaintenancePolicy.builder()+ .minHealthyPercentage(-1)+ .maxHealthyPercentage(-1)+ .build())+ .build());+ autoScaling.disableMetricsCollection(DisableMetricsCollectionRequest.builder()+ .autoScalingGroupName(autoScalingGroupName)+ .build());++ AutoScalingGroup cleared = describe(autoScalingGroupName);+ assertThat(cleared.instanceMaintenancePolicy()).isNull();+ assertThat(cleared.enabledMetrics()).isEmpty();+ assertThat(cleared.serviceLinkedRoleARN()).isEqualTo(roleArn);+ } finally {+ autoScaling.deleteAutoScalingGroup(DeleteAutoScalingGroupRequest.builder()+ .autoScalingGroupName(autoScalingGroupName)+ .forceDelete(true)+ .build());+ }+ }++ private static AutoScalingGroup describe(String autoScalingGroupName) {+ return autoScaling.describeAutoScalingGroups(r -> r.autoScalingGroupNames(autoScalingGroupName))+ .autoScalingGroups().get(0);+ }}diff --git a/docs/services/autoscaling.md b/docs/services/autoscaling.mdindex e28c519aee..da544e6ba3 100644--- a/docs/services/autoscaling.md+++ b/docs/services/autoscaling.md@@ -10,7 +10,7 @@ Floci implements the EC2 Auto Scaling API — stored-state management for launch- `arn:aws:autoscaling:<region>:<account>:launchConfiguration:<uuid>:launchConfigurationName/<name>`- `arn:aws:autoscaling:<region>:<account>:scalingPolicy:<uuid>:autoScalingGroupName/<group>/policyName/<name>`-## Supported Operations (45 total)+## Supported Operations (47 total)### Launch Configurations@@ -28,6 +28,8 @@ Floci implements the EC2 Auto Scaling API — stored-state management for launch| `DescribeAutoScalingGroups` | Filtered by name list; returns all if no filter; includes current instance list with lifecycle state and mixed instances policy shape when configured || `UpdateAutoScalingGroup` | Updates capacity bounds, cooldown, launch source, AZs || `DeleteAutoScalingGroup` | `ForceDelete=true` terminates all instances before deletion |+| `EnableMetricsCollection` | Records the named group metrics, or all 20 when none are named, as `EnabledMetrics` on `DescribeAutoScalingGroups`. `Granularity` is required and must be `1Minute`; an unknown metric name raises `ValidationError`. No metrics are published to CloudWatch |+| `DisableMetricsCollection` | Removes the named metrics from `EnabledMetrics`, or all of them when none are named |`CreateAutoScalingGroup` accepts both `subnet-a,subnet-b` and`subnet-a, subnet-b` in `VPCZoneIdentifier`. `DescribeAutoScalingGroups` returns the@@ -135,6 +137,7 @@ Auto Scaling groups preserve either a launch configuration, a top-level launch t- `LaunchTemplate.LaunchTemplateSpecification.LaunchTemplateName`- `LaunchTemplate.LaunchTemplateSpecification.Version`- `LaunchTemplate.Overrides.member.N.InstanceType`+- `LaunchTemplate.Overrides.member.N.WeightedCapacity`- `LaunchTemplate.Overrides.member.N.InstanceRequirements`- `InstancesDistribution.OnDemandBaseCapacity`- `InstancesDistribution.OnDemandPercentageAboveBaseCapacity`@@ -147,6 +150,10 @@ AWS model marks required on that shape, and raises `ValidationError` otherwise.`InstanceRequirements` shape round-trips except `BaselinePerformanceFactors`, which is accepted anddropped.+`WeightedCapacity` must be an integer from 1 to 999 written in at most 32 characters, and once+one override sets it every override must, as the AWS model requires. Either rule raises+`ValidationError` otherwise.+A group uses attribute-based instance type selection when the mixed instances policy left in effectby the request carries at least one launch template override with `InstanceRequirements`. On createthat is the policy the request supplies. On update it is the policy the request supplies, the stored@@ -165,6 +172,13 @@ never set a field omits it from the response rather than reporting a default.| `CapacityRebalance` | Stored and echoed as a boolean || `MaxInstanceLifetime` | Seconds. Must be `0` or at least `86400`. `0` means no maximum and is echoed back as `0` || `DefaultInstanceWarmup` | Seconds. Pass `-1` to remove a value already set, after which the field is omitted again |+| `ServiceLinkedRoleARN` | Stored and echoed as given, 1 to 1600 characters. Floci does not check that the role exists, and a group that never set it omits it rather than reporting the default `AWSServiceRoleForAutoScaling` role |+| `InstanceMaintenancePolicy` | `MinHealthyPercentage` 0 to 100 and `MaxHealthyPercentage` 100 to 200, both required, at most 100 apart. `-1` on both clears a policy already set. Any other combination raises `ValidationError` |+| `AvailabilityZoneDistribution` | `CapacityDistributionStrategy` is one of `balanced-only`, `balanced-best-effort`, `reservations-then-balanced` |+| `CapacityReservationSpecification` | `CapacityReservationPreference` is one of `capacity-reservations-only`, `capacity-reservations-first`, `none`, `default`. `CapacityReservationTarget` (`CapacityReservationIds`, `CapacityReservationResourceGroupArns`) round-trips, and is rejected alongside `none`. Each ID is 1 to 255 characters of `[A-Za-z0-9-_/]` and each resource group ARN is 1 to 1600 characters |++These fields are stored and reported only. Floci's capacity reconciler does not change how it+launches or replaces instances because of them.## Scaling Policy Compatibilitydiff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex c226848d64..aa350af190 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -282,7 +282,16 @@ accepts, not only by name:- `MixedInstancesPolicy` → `LaunchTemplate` → `LaunchTemplateSpecification`, including`Overrides[].InstanceType` and `InstancesDistribution` (`OnDemandBaseCapacity`,`OnDemandPercentageAboveBaseCapacity`, `SpotAllocationStrategy`). A non-integer where AWS expects- a number fails the stack rather than being dropped.+ a number fails the stack rather than being dropped. `Overrides[].WeightedCapacity` is carried+ through as well.++The group also passes `ServiceLinkedRoleARN`, `InstanceMaintenancePolicy`,+`AvailabilityZoneDistribution` and `CapacityReservationSpecification` through to the group, with+the same validation the Auto Scaling API applies. The resource schema requires+`CapacityReservationPreference` on `CapacityReservationSpecification` and `Granularity` on each+`MetricsCollection` entry. `MetricsCollection` enables the listed metrics (an entry naming none+enables all of them), and on `UpdateStack` the group's enabled metrics are+set to exactly what the template lists. Removing the property leaves collection as it was.## Lambda Stack Updatesdiff --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 bc45926c37..fe6962402d 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@@ -162,7 +162,8 @@ public class AwsQueryController {"DescribeScalingActivities","DescribeAutoScalingNotificationTypes", "DescribeTerminationPolicyTypes","DescribeAdjustmentTypes", "DescribeAccountLimits",- "DescribeLifecycleHookTypes", "DescribeMetricCollectionTypes"+ "DescribeLifecycleHookTypes", "DescribeMetricCollectionTypes",+ "EnableMetricsCollection", "DisableMetricsCollection");private static final Set<String> ELB_V2_ACTIONS = Set.of(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 4ab0ad8dbc..542a565067 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@@ -55,6 +55,8 @@ public class AutoScalingQueryHandler {case "DescribeInstanceRefreshes" -> handleDescribeInstanceRefreshes(p, region);case "CreateOrUpdateTags" -> handleCreateOrUpdateTags(p, region);case "DeleteTags" -> handleDeleteTags(p, region);+ case "EnableMetricsCollection" -> handleEnableMetricsCollection(p, region);+ case "DisableMetricsCollection" -> handleDisableMetricsCollection(p, region);// Instancescase "DescribeAutoScalingInstances" -> handleDescribeAutoScalingInstances(p, region);case "SetInstanceProtection" -> handleSetInstanceProtection(p, region);@@ -287,6 +289,13 @@ public class AutoScalingQueryHandler {if (asg.getDefaultInstanceWarmup() != null) {xml.elem("DefaultInstanceWarmup", String.valueOf(asg.getDefaultInstanceWarmup()));}+ if (asg.getServiceLinkedRoleArn() != null) {+ xml.elem("ServiceLinkedRoleARN", asg.getServiceLinkedRoleArn());+ }+ appendInstanceMaintenancePolicyXml(xml, asg.getInstanceMaintenancePolicy());+ appendAvailabilityZoneDistributionXml(xml, asg.getAvailabilityZoneDistribution());+ appendCapacityReservationSpecificationXml(xml, asg.getCapacityReservationSpecification());+ appendEnabledMetricsXml(xml, asg.getEnabledMetrics());if (asg.getLaunchConfigurationName() != null) {xml.elem("LaunchConfigurationName", asg.getLaunchConfigurationName());}@@ -482,6 +491,23 @@ public class AutoScalingQueryHandler {.end("CreateOrUpdateTagsResponse").build());}+ private Response handleEnableMetricsCollection(MultivaluedMap<String, String> p, String region) {+ service.enableMetricsCollection(region, p.getFirst("AutoScalingGroupName"),+ memberList(p, "Metrics"), p.getFirst("Granularity"));+ return ok(new XmlBuilder()+ .start("EnableMetricsCollectionResponse", NS)+ .raw(AwsQueryResponse.responseMetadata())+ .end("EnableMetricsCollectionResponse").build());+ }++ private Response handleDisableMetricsCollection(MultivaluedMap<String, String> p, String region) {+ service.disableMetricsCollection(region, p.getFirst("AutoScalingGroupName"), memberList(p, "Metrics"));+ return ok(new XmlBuilder()+ .start("DisableMetricsCollectionResponse", NS)+ .raw(AwsQueryResponse.responseMetadata())+ .end("DisableMetricsCollectionResponse").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()));@@ -565,6 +591,74 @@ public class AutoScalingQueryHandler {xml.end("LaunchTemplate");}+ private static void appendInstanceMaintenancePolicyXml(XmlBuilder xml, InstanceMaintenancePolicy policy) {+ if (policy == null) {+ return;+ }+ xml.start("InstanceMaintenancePolicy");+ if (policy.getMinHealthyPercentage() != null) {+ xml.elem("MinHealthyPercentage", String.valueOf(policy.getMinHealthyPercentage()));+ }+ if (policy.getMaxHealthyPercentage() != null) {+ xml.elem("MaxHealthyPercentage", String.valueOf(policy.getMaxHealthyPercentage()));+ }+ xml.end("InstanceMaintenancePolicy");+ }++ private static void appendAvailabilityZoneDistributionXml(XmlBuilder xml,+ AvailabilityZoneDistribution distribution) {+ if (distribution == null || distribution.getCapacityDistributionStrategy() == null) {+ return;+ }+ xml.start("AvailabilityZoneDistribution")+ .elem("CapacityDistributionStrategy", distribution.getCapacityDistributionStrategy())+ .end("AvailabilityZoneDistribution");+ }++ private static void appendCapacityReservationSpecificationXml(XmlBuilder xml,+ CapacityReservationSpecification specification) {+ if (specification == null) {+ return;+ }+ xml.start("CapacityReservationSpecification");+ if (specification.getCapacityReservationPreference() != null) {+ xml.elem("CapacityReservationPreference", specification.getCapacityReservationPreference());+ }+ if (specification.hasTarget()) {+ xml.start("CapacityReservationTarget");+ if (!specification.getCapacityReservationIds().isEmpty()) {+ xml.start("CapacityReservationIds");+ for (String id : specification.getCapacityReservationIds()) {+ xml.elem("member", id);+ }+ xml.end("CapacityReservationIds");+ }+ if (!specification.getCapacityReservationResourceGroupArns().isEmpty()) {+ xml.start("CapacityReservationResourceGroupArns");+ for (String arn : specification.getCapacityReservationResourceGroupArns()) {+ xml.elem("member", arn);+ }+ xml.end("CapacityReservationResourceGroupArns");+ }+ xml.end("CapacityReservationTarget");+ }+ xml.end("CapacityReservationSpecification");+ }++ private static void appendEnabledMetricsXml(XmlBuilder xml, List<String> enabledMetrics) {+ if (enabledMetrics == null || enabledMetrics.isEmpty()) {+ return;+ }+ xml.start("EnabledMetrics");+ for (String metric : enabledMetrics) {+ xml.start("member")+ .elem("Metric", metric)+ .elem("Granularity", AutoScalingService.METRICS_GRANULARITY)+ .end("member");+ }+ xml.end("EnabledMetrics");+ }+private static void appendMixedInstancesPolicyXml(XmlBuilder xml, MixedInstancesPolicy policy) {if (policy == null) {return;@@ -581,6 +675,9 @@ public class AutoScalingQueryHandler {if (override.getInstanceType() != null) {xml.elem("InstanceType", override.getInstanceType());}+ if (override.getWeightedCapacity() != null) {+ xml.elem("WeightedCapacity", override.getWeightedCapacity());+ }appendInstanceRequirementsXml(xml, override.getInstanceRequirements());xml.end("member");}@@ -1386,6 +1483,7 @@ public class AutoScalingQueryHandler {MixedInstancesPolicy.LaunchTemplateOverride override =new MixedInstancesPolicy.LaunchTemplateOverride();override.setInstanceType(p.getFirst(prefix + ".InstanceType"));+ override.setWeightedCapacity(p.getFirst(prefix + ".WeightedCapacity"));override.setInstanceRequirements(parseInstanceRequirements(p, prefix + ".InstanceRequirements"));result.add(override);}@@ -1455,7 +1553,42 @@ public class AutoScalingQueryHandler {p.getFirst("DesiredCapacityType"),nullableBoolParam(p, "CapacityRebalance"),parseOptionalInt(p.getFirst("MaxInstanceLifetime"), "MaxInstanceLifetime"),- parseOptionalInt(p.getFirst("DefaultInstanceWarmup"), "DefaultInstanceWarmup"));+ parseOptionalInt(p.getFirst("DefaultInstanceWarmup"), "DefaultInstanceWarmup"),+ p.getFirst("ServiceLinkedRoleARN"),+ parseInstanceMaintenancePolicy(p),+ parseAvailabilityZoneDistribution(p),+ parseCapacityReservationSpecification(p));+ }++ private InstanceMaintenancePolicy parseInstanceMaintenancePolicy(MultivaluedMap<String, String> p) {+ if (!hasAnyPrefix(p, "InstanceMaintenancePolicy.")) {+ return null;+ }+ return new InstanceMaintenancePolicy(+ parseOptionalInt(p.getFirst("InstanceMaintenancePolicy.MinHealthyPercentage"),+ "InstanceMaintenancePolicy.MinHealthyPercentage"),+ parseOptionalInt(p.getFirst("InstanceMaintenancePolicy.MaxHealthyPercentage"),+ "InstanceMaintenancePolicy.MaxHealthyPercentage"));+ }++ private AvailabilityZoneDistribution parseAvailabilityZoneDistribution(MultivaluedMap<String, String> p) {+ String strategy = p.getFirst("AvailabilityZoneDistribution.CapacityDistributionStrategy");+ return strategy != null ? new AvailabilityZoneDistribution(strategy) : null;+ }++ private CapacityReservationSpecification parseCapacityReservationSpecification(+ MultivaluedMap<String, String> p) {+ String prefix = "CapacityReservationSpecification.";+ if (!hasAnyPrefix(p, prefix)) {+ return null;+ }+ CapacityReservationSpecification specification = new CapacityReservationSpecification();+ specification.setCapacityReservationPreference(p.getFirst(prefix + "CapacityReservationPreference"));+ specification.setCapacityReservationIds(+ memberList(p, prefix + "CapacityReservationTarget.CapacityReservationIds"));+ specification.setCapacityReservationResourceGroupArns(+ memberList(p, prefix + "CapacityReservationTarget.CapacityReservationResourceGroupArns"));+ return specification;}private ParsedTags parseTags(MultivaluedMap<String, String> p) {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 ca5dcc5309..2b9bd9387c 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@@ -49,6 +49,55 @@ public class AutoScalingService {"Amazon EC2 Auto Scaling supports DesiredCapacityType for attribute-based instance type "+ "selection only. Specify InstanceRequirements on a MixedInstancesPolicy launch "+ "template override, or use the default DesiredCapacityType of units.";+ static final String INSTANCE_MAINTENANCE_POLICY_BOTH_REQUIRED_MESSAGE =+ "Both MinHealthyPercentage and MaxHealthyPercentage must be specified in InstanceMaintenancePolicy.";+ static final String INVALID_MIN_HEALTHY_PERCENTAGE_MESSAGE =+ "MinHealthyPercentage must be between 0 and 100, or -1 to clear a previously set value.";+ static final String INVALID_MAX_HEALTHY_PERCENTAGE_MESSAGE =+ "MaxHealthyPercentage must be between 100 and 200, or -1 to clear a previously set value.";+ static final String INSTANCE_MAINTENANCE_POLICY_PARTIAL_CLEAR_MESSAGE =+ "To clear an InstanceMaintenancePolicy, specify -1 for both MinHealthyPercentage and MaxHealthyPercentage.";+ static final String INSTANCE_MAINTENANCE_POLICY_RANGE_MESSAGE =+ "The difference between MaxHealthyPercentage and MinHealthyPercentage cannot be greater than 100.";+ static final Set<String> CAPACITY_DISTRIBUTION_STRATEGIES =+ Set.of("balanced-only", "balanced-best-effort", "reservations-then-balanced");+ static final String INVALID_CAPACITY_DISTRIBUTION_STRATEGY_MESSAGE =+ "The specified value for CapacityDistributionStrategy is not valid. Valid values are: "+ + "balanced-only, balanced-best-effort, reservations-then-balanced.";+ static final Set<String> CAPACITY_RESERVATION_PREFERENCES =+ Set.of("capacity-reservations-only", "capacity-reservations-first", "none", "default");+ static final String INVALID_CAPACITY_RESERVATION_PREFERENCE_MESSAGE =+ "The specified value for CapacityReservationPreference is not valid. Valid values are: "+ + "capacity-reservations-only, capacity-reservations-first, none, default.";+ static final String CAPACITY_RESERVATION_TARGET_WITH_NONE_MESSAGE =+ "You cannot specify a CapacityReservationTarget when CapacityReservationPreference is none.";+ static final int MAX_SERVICE_LINKED_ROLE_ARN_LENGTH = 1600;+ static final int MAX_RESOURCE_NAME_LENGTH = 1600;+ private static final Pattern CAPACITY_RESERVATION_ID_PATTERN = Pattern.compile("^[A-Za-z0-9\\-_/]+$");+ static final int MAX_WEIGHTED_CAPACITY_LENGTH = 32;+ static final String INVALID_SERVICE_LINKED_ROLE_ARN_MESSAGE =+ "ServiceLinkedRoleARN must be between 1 and 1600 characters long.";+ static final int MIN_WEIGHTED_CAPACITY = 1;+ static final int MAX_WEIGHTED_CAPACITY = 999;+ static final String INVALID_WEIGHTED_CAPACITY_MESSAGE =+ "WeightedCapacity must be an integer in the range of 1-999.";+ static final String PARTIAL_WEIGHTED_CAPACITY_MESSAGE =+ "If you specify a value for WeightedCapacity for one instance type, you must specify a value "+ + "for WeightedCapacity for all of them.";+ public static final List<String> GROUP_METRICS = List.of(+ "GroupMinSize", "GroupMaxSize", "GroupDesiredCapacity", "GroupInServiceInstances",+ "GroupPendingInstances", "GroupStandbyInstances", "GroupTerminatingInstances",+ "GroupTotalInstances", "GroupInServiceCapacity", "GroupPendingCapacity",+ "GroupStandbyCapacity", "GroupTerminatingCapacity", "GroupTotalCapacity",+ "WarmPoolDesiredCapacity", "WarmPoolWarmedCapacity", "WarmPoolPendingCapacity",+ "WarmPoolTerminatingCapacity", "WarmPoolTotalCapacity",+ "GroupAndWarmPoolDesiredCapacity", "GroupAndWarmPoolTotalCapacity");+ public static final String METRICS_GRANULARITY = "1Minute";+ static final String MISSING_GRANULARITY_MESSAGE =+ "1 validation error detected: Value null at 'granularity' failed to satisfy constraint: "+ + "Member must not be null";+ public static final String INVALID_GRANULARITY_MESSAGE =+ "Granularity must be 1Minute. 1Minute is the only valid value.";static final String ACTIVE_INSTANCE_REFRESH_DESIRED_CONFIGURATION_MESSAGE ="An active instance refresh with a desired configuration exists. All configuration options derived from the desired configuration are not available for update while the instance refresh is active.";@@ -332,6 +381,58 @@ public class AutoScalingService {groups.put(asgKey(region, name), asg);}+ /**+ * EnableMetricsCollection: {@code Granularity} is required and 1Minute is its only valid value.+ * Naming no metrics enables all of them.+ */+ public void enableMetricsCollection(String region, String name, List<String> metrics, String granularity) {+ if (granularity == null) {+ throw new AwsException("ValidationError", MISSING_GRANULARITY_MESSAGE, 400);+ }+ if (!METRICS_GRANULARITY.equals(granularity)) {+ throw new AwsException("ValidationError", INVALID_GRANULARITY_MESSAGE, 400);+ }+ validateMetricNames(metrics);+ String key = asgKey(region, name);+ synchronized (lockFor(key)) {+ AutoScalingGroup asg = requireGroup(region, name);+ List<String> requested = metrics == null || metrics.isEmpty() ? GROUP_METRICS : metrics;+ LinkedHashSet<String> enabled = new LinkedHashSet<>(asg.getEnabledMetrics());+ enabled.addAll(requested);+ asg.setEnabledMetrics(new ArrayList<>(enabled));+ groups.put(key, asg);+ }+ }++ /** DisableMetricsCollection: naming no metrics disables all of them. */+ public void disableMetricsCollection(String region, String name, List<String> metrics) {+ validateMetricNames(metrics);+ String key = asgKey(region, name);+ synchronized (lockFor(key)) {+ AutoScalingGroup asg = requireGroup(region, name);+ if (metrics == null || metrics.isEmpty()) {+ asg.setEnabledMetrics(new ArrayList<>());+ } else {+ List<String> remaining = new ArrayList<>(asg.getEnabledMetrics());+ remaining.removeAll(metrics);+ asg.setEnabledMetrics(remaining);+ }+ groups.put(key, asg);+ }+ }++ public static void validateMetricNames(List<String> metrics) {+ if (metrics == null) {+ return;+ }+ for (String metric : metrics) {+ if (!GROUP_METRICS.contains(metric)) {+ throw new AwsException("ValidationError",+ "Metric " + metric + " is not a valid Auto Scaling group metric.", 400);+ }+ }+ }+public void deleteAutoScalingGroup(String region, String name, boolean forceDelete) {String key = asgKey(region, name);synchronized (lockFor(key)) {@@ -1109,6 +1210,7 @@ public class AutoScalingService {}private static void validateLaunchTemplateOverrides(MixedInstancesPolicy mixedInstancesPolicy) {+ validateWeightedCapacities(overridesOf(mixedInstancesPolicy));for (MixedInstancesPolicy.LaunchTemplateOverride override : overridesOf(mixedInstancesPolicy)) {MixedInstancesPolicy.InstanceRequirements requirements = override.getInstanceRequirements();if (requirements == null || requirements.isEmpty()) {@@ -1125,6 +1227,36 @@ public class AutoScalingService {}}+ /**+ * Botocore types {@code WeightedCapacity} as a string of 1-32 characters, while its prose+ * requires a value in the range 1-999 and requires every override to carry one once any does.+ */+ private static void validateWeightedCapacities(List<MixedInstancesPolicy.LaunchTemplateOverride> overrides) {+ int weighted = 0;+ for (MixedInstancesPolicy.LaunchTemplateOverride override : overrides) {+ String weightedCapacity = override.getWeightedCapacity();+ if (weightedCapacity == null) {+ continue;+ }+ weighted++;+ if (weightedCapacity.isEmpty() || weightedCapacity.length() > MAX_WEIGHTED_CAPACITY_LENGTH) {+ throw new AwsException("ValidationError", INVALID_WEIGHTED_CAPACITY_MESSAGE, 400);+ }+ int value;+ try {+ value = Integer.parseInt(weightedCapacity.trim());+ } catch (NumberFormatException e) {+ throw new AwsException("ValidationError", INVALID_WEIGHTED_CAPACITY_MESSAGE, 400);+ }+ if (value < MIN_WEIGHTED_CAPACITY || value > MAX_WEIGHTED_CAPACITY) {+ throw new AwsException("ValidationError", INVALID_WEIGHTED_CAPACITY_MESSAGE, 400);+ }+ }+ if (weighted > 0 && weighted < overrides.size()) {+ throw new AwsException("ValidationError", PARTIAL_WEIGHTED_CAPACITY_MESSAGE, 400);+ }+ }+/*** Botocore documents {@code DesiredCapacityType} as supported "for attribute-based instance type* selection only", and it types the member as a plain string rather than an enum, so the rule@@ -1196,6 +1328,81 @@ public class AutoScalingService {&& defaultInstanceWarmup < AsgOptionalFields.DEFAULT_INSTANCE_WARMUP_REMOVAL_SENTINEL) {throw new AwsException("ValidationError", INVALID_DEFAULT_INSTANCE_WARMUP_MESSAGE, 400);}+ String serviceLinkedRoleArn = optionalFields.serviceLinkedRoleArn();+ if (serviceLinkedRoleArn != null+ && (serviceLinkedRoleArn.isEmpty() || serviceLinkedRoleArn.length() > MAX_SERVICE_LINKED_ROLE_ARN_LENGTH)) {+ throw new AwsException("ValidationError", INVALID_SERVICE_LINKED_ROLE_ARN_MESSAGE, 400);+ }+ validateInstanceMaintenancePolicy(optionalFields.instanceMaintenancePolicy());+ AvailabilityZoneDistribution azDistribution = optionalFields.availabilityZoneDistribution();+ if (azDistribution != null && azDistribution.getCapacityDistributionStrategy() != null+ && !CAPACITY_DISTRIBUTION_STRATEGIES.contains(azDistribution.getCapacityDistributionStrategy())) {+ throw new AwsException("ValidationError", INVALID_CAPACITY_DISTRIBUTION_STRATEGY_MESSAGE, 400);+ }+ validateCapacityReservationSpecification(optionalFields.capacityReservationSpecification());+ }++ /**+ * Botocore bounds MinHealthyPercentage to [-1, 100] and MaxHealthyPercentage to [-1, 200], and+ * its prose narrows the maximum to 100-200, requires both members, caps their difference at 100,+ * and reserves -1 for clearing a previously set policy.+ */+ private static void validateInstanceMaintenancePolicy(InstanceMaintenancePolicy policy) {+ if (policy == null) {+ return;+ }+ Integer min = policy.getMinHealthyPercentage();+ Integer max = policy.getMaxHealthyPercentage();+ if (min == null || max == null) {+ throw new AwsException("ValidationError", INSTANCE_MAINTENANCE_POLICY_BOTH_REQUIRED_MESSAGE, 400);+ }+ if (policy.isRemoval()) {+ return;+ }+ if (min == InstanceMaintenancePolicy.REMOVAL_SENTINEL || max == InstanceMaintenancePolicy.REMOVAL_SENTINEL) {+ throw new AwsException("ValidationError", INSTANCE_MAINTENANCE_POLICY_PARTIAL_CLEAR_MESSAGE, 400);+ }+ if (min < 0 || min > 100) {+ throw new AwsException("ValidationError", INVALID_MIN_HEALTHY_PERCENTAGE_MESSAGE, 400);+ }+ if (max < 100 || max > 200) {+ throw new AwsException("ValidationError", INVALID_MAX_HEALTHY_PERCENTAGE_MESSAGE, 400);+ }+ if (max - min > 100) {+ throw new AwsException("ValidationError", INSTANCE_MAINTENANCE_POLICY_RANGE_MESSAGE, 400);+ }+ }++ private static void validateCapacityReservationSpecification(CapacityReservationSpecification specification) {+ if (specification == null) {+ return;+ }+ String preference = specification.getCapacityReservationPreference();+ if (preference != null && !CAPACITY_RESERVATION_PREFERENCES.contains(preference)) {+ throw new AwsException("ValidationError", INVALID_CAPACITY_RESERVATION_PREFERENCE_MESSAGE, 400);+ }+ if ("none".equals(preference) && specification.hasTarget()) {+ throw new AwsException("ValidationError", CAPACITY_RESERVATION_TARGET_WITH_NONE_MESSAGE, 400);+ }+ for (String id : specification.getCapacityReservationIds()) {+ if (id == null || id.isEmpty() || id.length() > 255+ || !CAPACITY_RESERVATION_ID_PATTERN.matcher(id).matches()) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value '" + id+ + "' at 'capacityReservationSpecification.capacityReservationTarget"+ + ".capacityReservationIds' failed to satisfy constraint: Member must have length "+ + "between 1 and 255 and satisfy regular expression pattern: [A-Za-z0-9\\-_\\/]+",+ 400);+ }+ }+ for (String arn : specification.getCapacityReservationResourceGroupArns()) {+ if (arn == null || arn.isEmpty() || arn.length() > MAX_RESOURCE_NAME_LENGTH) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value at 'capacityReservationSpecification"+ + ".capacityReservationTarget.capacityReservationResourceGroupArns' failed to "+ + "satisfy constraint: Member must have length between 1 and 1600", 400);+ }+ }}private static boolean hasUsableLaunchTemplate(MixedInstancesPolicy mixedInstancesPolicy) {diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgOptionalFields.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgOptionalFields.javaindex b746c453a8..dbbb51a160 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgOptionalFields.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AsgOptionalFields.java@@ -1,28 +1,42 @@package io.github.hectorvent.floci.services.autoscaling.model;/**- * The optional scalar members that {@code CreateAutoScalingGroup} and- * {@code UpdateAutoScalingGroup} share and that {@code DescribeAutoScalingGroups} echoes back.+ * The optional members that {@code CreateAutoScalingGroup} and {@code UpdateAutoScalingGroup}+ * share and that {@code DescribeAutoScalingGroups} echoes back.*- * <p>Carried as one object rather than four more positional parameters on+ * <p>Carried as one object rather than more positional parameters on* {@code AutoScalingService.createAutoScalingGroup}, whose argument list is already long.** <p>A {@code null} component means the request did not set the member. On update that means* "leave the stored value alone", which is UpdateAutoScalingGroup's partial-update behaviour for* every other member.*- * <p>{@code DefaultInstanceWarmup} carries a sentinel: botocore documents {@code -1} as the value- * that removes a previously set warmup, so it clears the stored value instead of storing -1.+ * <p>Two members carry a removal sentinel. Botocore documents {@code -1} as the value that removes+ * a previously set {@code DefaultInstanceWarmup}, and {@code -1} on the percentages of+ * {@code InstanceMaintenancePolicy} as the value that clears that policy. Both clear the stored+ * value instead of storing -1.*/public record AsgOptionalFields(String desiredCapacityType,Boolean capacityRebalance,Integer maxInstanceLifetime,- Integer defaultInstanceWarmup) {+ Integer defaultInstanceWarmup,+ String serviceLinkedRoleArn,+ InstanceMaintenancePolicy instanceMaintenancePolicy,+ AvailabilityZoneDistribution availabilityZoneDistribution,+ CapacityReservationSpecification capacityReservationSpecification) {public static final int DEFAULT_INSTANCE_WARMUP_REMOVAL_SENTINEL = -1;private static final AsgOptionalFields NONE = new AsgOptionalFields(null, null, null, null);+ public AsgOptionalFields(String desiredCapacityType,+ Boolean capacityRebalance,+ Integer maxInstanceLifetime,+ Integer defaultInstanceWarmup) {+ this(desiredCapacityType, capacityRebalance, maxInstanceLifetime, defaultInstanceWarmup,+ null, null, null, null);+ }+public static AsgOptionalFields none() {return NONE;}@@ -33,6 +47,10 @@ public record AsgOptionalFields(String desiredCapacityType,asg.setCapacityRebalance(capacityRebalance);asg.setMaxInstanceLifetime(maxInstanceLifetime);asg.setDefaultInstanceWarmup(resolvedDefaultInstanceWarmup());+ asg.setServiceLinkedRoleArn(serviceLinkedRoleArn);+ asg.setInstanceMaintenancePolicy(resolvedInstanceMaintenancePolicy());+ asg.setAvailabilityZoneDistribution(availabilityZoneDistribution);+ asg.setCapacityReservationSpecification(capacityReservationSpecification);}/** Applies onto an existing group, overwriting only the members this request set. */@@ -49,6 +67,18 @@ public record AsgOptionalFields(String desiredCapacityType,if (defaultInstanceWarmup != null) {asg.setDefaultInstanceWarmup(resolvedDefaultInstanceWarmup());}+ if (serviceLinkedRoleArn != null) {+ asg.setServiceLinkedRoleArn(serviceLinkedRoleArn);+ }+ if (instanceMaintenancePolicy != null) {+ asg.setInstanceMaintenancePolicy(resolvedInstanceMaintenancePolicy());+ }+ if (availabilityZoneDistribution != null) {+ asg.setAvailabilityZoneDistribution(availabilityZoneDistribution);+ }+ if (capacityReservationSpecification != null) {+ asg.setCapacityReservationSpecification(capacityReservationSpecification);+ }}private Integer resolvedDefaultInstanceWarmup() {@@ -58,4 +88,11 @@ public record AsgOptionalFields(String desiredCapacityType,}return defaultInstanceWarmup;}++ private InstanceMaintenancePolicy resolvedInstanceMaintenancePolicy() {+ if (instanceMaintenancePolicy != null && instanceMaintenancePolicy.isRemoval()) {+ return null;+ }+ return instanceMaintenancePolicy;+ }}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 93c89697a1..b115a9c280 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@@ -50,6 +50,13 @@ public class AutoScalingGroup {private Boolean capacityRebalance;private Integer maxInstanceLifetime;private Integer defaultInstanceWarmup;+ private String serviceLinkedRoleArn;+ private InstanceMaintenancePolicy instanceMaintenancePolicy;+ private AvailabilityZoneDistribution availabilityZoneDistribution;+ private CapacityReservationSpecification capacityReservationSpecification;+ // Set only by EnableMetricsCollection/DisableMetricsCollection. 1Minute is the only granularity+ // the model allows, so the metric names are all that needs storing.+ private List<String> enabledMetrics = new ArrayList<>();public AutoScalingGroup() {}@@ -142,4 +149,19 @@ public class AutoScalingGroup {public Integer getDefaultInstanceWarmup() { return defaultInstanceWarmup; }public void setDefaultInstanceWarmup(Integer v) { this.defaultInstanceWarmup = v; }++ public String getServiceLinkedRoleArn() { return serviceLinkedRoleArn; }+ public void setServiceLinkedRoleArn(String v) { this.serviceLinkedRoleArn = v; }++ public InstanceMaintenancePolicy getInstanceMaintenancePolicy() { return instanceMaintenancePolicy; }+ public void setInstanceMaintenancePolicy(InstanceMaintenancePolicy v) { this.instanceMaintenancePolicy = v; }++ public AvailabilityZoneDistribution getAvailabilityZoneDistribution() { return availabilityZoneDistribution; }+ public void setAvailabilityZoneDistribution(AvailabilityZoneDistribution v) { this.availabilityZoneDistribution = v; }++ public CapacityReservationSpecification getCapacityReservationSpecification() { return capacityReservationSpecification; }+ public void setCapacityReservationSpecification(CapacityReservationSpecification v) { this.capacityReservationSpecification = v; }++ public List<String> getEnabledMetrics() { return enabledMetrics; }+ public void setEnabledMetrics(List<String> v) { this.enabledMetrics = v != null ? new ArrayList<>(v) : new ArrayList<>(); }}diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AvailabilityZoneDistribution.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AvailabilityZoneDistribution.javanew file mode 100644index 0000000000..710642a8af--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/AvailabilityZoneDistribution.java@@ -0,0 +1,24 @@+package io.github.hectorvent.floci.services.autoscaling.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * The {@code AvailabilityZoneDistribution} member of CreateAutoScalingGroup, UpdateAutoScalingGroup+ * and the {@code AutoScalingGroup} shape.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class AvailabilityZoneDistribution {++ private String capacityDistributionStrategy;++ public AvailabilityZoneDistribution() {}++ public AvailabilityZoneDistribution(String capacityDistributionStrategy) {+ this.capacityDistributionStrategy = capacityDistributionStrategy;+ }++ public String getCapacityDistributionStrategy() { return capacityDistributionStrategy; }+ public void setCapacityDistributionStrategy(String v) { this.capacityDistributionStrategy = v; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/CapacityReservationSpecification.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/CapacityReservationSpecification.javanew file mode 100644index 0000000000..aa73786c76--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/CapacityReservationSpecification.java@@ -0,0 +1,42 @@+package io.github.hectorvent.floci.services.autoscaling.model;++import com.fasterxml.jackson.annotation.JsonIgnore;+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.List;++/**+ * The {@code CapacityReservationSpecification} member of CreateAutoScalingGroup,+ * UpdateAutoScalingGroup and the {@code AutoScalingGroup} shape, with its+ * {@code CapacityReservationTarget} flattened into the two lists that target carries.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class CapacityReservationSpecification {++ private String capacityReservationPreference;+ private List<String> capacityReservationIds = new ArrayList<>();+ private List<String> capacityReservationResourceGroupArns = new ArrayList<>();++ public CapacityReservationSpecification() {}++ public String getCapacityReservationPreference() { return capacityReservationPreference; }+ public void setCapacityReservationPreference(String v) { this.capacityReservationPreference = v; }++ public List<String> getCapacityReservationIds() { return capacityReservationIds; }+ public void setCapacityReservationIds(List<String> v) {+ this.capacityReservationIds = v != null ? new ArrayList<>(v) : new ArrayList<>();+ }++ public List<String> getCapacityReservationResourceGroupArns() { return capacityReservationResourceGroupArns; }+ public void setCapacityReservationResourceGroupArns(List<String> v) {+ this.capacityReservationResourceGroupArns = v != null ? new ArrayList<>(v) : new ArrayList<>();+ }++ @JsonIgnore+ public boolean hasTarget() {+ return !capacityReservationIds.isEmpty() || !capacityReservationResourceGroupArns.isEmpty();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/InstanceMaintenancePolicy.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/InstanceMaintenancePolicy.javanew file mode 100644index 0000000000..86a3952bd0--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/InstanceMaintenancePolicy.java@@ -0,0 +1,39 @@+package io.github.hectorvent.floci.services.autoscaling.model;++import com.fasterxml.jackson.annotation.JsonIgnore;+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * The {@code InstanceMaintenancePolicy} member of CreateAutoScalingGroup, UpdateAutoScalingGroup+ * and the {@code AutoScalingGroup} shape. Botocore documents {@code -1} on either percentage as the+ * value that clears a previously set policy.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class InstanceMaintenancePolicy {++ public static final int REMOVAL_SENTINEL = -1;++ private Integer minHealthyPercentage;+ private Integer maxHealthyPercentage;++ public InstanceMaintenancePolicy() {}++ public InstanceMaintenancePolicy(Integer minHealthyPercentage, Integer maxHealthyPercentage) {+ this.minHealthyPercentage = minHealthyPercentage;+ this.maxHealthyPercentage = maxHealthyPercentage;+ }++ 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; }++ @JsonIgnore+ public boolean isRemoval() {+ return Integer.valueOf(REMOVAL_SENTINEL).equals(minHealthyPercentage)+ && Integer.valueOf(REMOVAL_SENTINEL).equals(maxHealthyPercentage);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/MixedInstancesPolicy.java b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/MixedInstancesPolicy.javaindex 912474fc42..80a3b54a67 100644--- a/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/MixedInstancesPolicy.java+++ b/src/main/java/io/github/hectorvent/floci/services/autoscaling/model/MixedInstancesPolicy.java@@ -58,6 +58,7 @@ public class MixedInstancesPolicy {@JsonIgnoreProperties(ignoreUnknown = true)public static class LaunchTemplateOverride {private String instanceType;+ private String weightedCapacity;private InstanceRequirements instanceRequirements;public LaunchTemplateOverride() {}@@ -65,6 +66,9 @@ public class MixedInstancesPolicy {public String getInstanceType() { return instanceType; }public void setInstanceType(String v) { this.instanceType = v; }+ public String getWeightedCapacity() { return weightedCapacity; }+ public void setWeightedCapacity(String v) { this.weightedCapacity = v; }+public InstanceRequirements getInstanceRequirements() { return instanceRequirements; }public void setInstanceRequirements(InstanceRequirements v) { this.instanceRequirements = v; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisioner.javaindex 7351d052a0..9bb42316a7 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisioner.java@@ -7,6 +7,9 @@ import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.autoscaling.AutoScalingService;import io.github.hectorvent.floci.services.autoscaling.model.AsgOptionalFields;import io.github.hectorvent.floci.services.autoscaling.model.AutoScalingGroup;+import io.github.hectorvent.floci.services.autoscaling.model.AvailabilityZoneDistribution;+import io.github.hectorvent.floci.services.autoscaling.model.CapacityReservationSpecification;+import io.github.hectorvent.floci.services.autoscaling.model.InstanceMaintenancePolicy;import io.github.hectorvent.floci.services.autoscaling.model.LaunchConfiguration;import io.github.hectorvent.floci.services.autoscaling.model.MixedInstancesPolicy;import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;@@ -15,6 +18,7 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;+import java.util.ArrayList;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;@@ -84,13 +88,23 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {AsgSnapshot snapshot = MAPPER.readValue(rawSnapshot, AsgSnapshot.class);// UpdateAutoScalingGroup treats null as "leave unchanged". Restore an unset// snapshot member with its API default instead; -1 removes DefaultInstanceWarmup.+ // InstanceMaintenancePolicy clears with -1 on both percentages. The service-linked+ // role, AZ distribution and capacity reservation members have no clearing value+ // on UpdateAutoScalingGroup, so an unset snapshot member is cleared afterwards.AsgOptionalFields optionalFields = new AsgOptionalFields(snapshot.desiredCapacityType() != null ? snapshot.desiredCapacityType() : "units",snapshot.capacityRebalance() != null ? snapshot.capacityRebalance() : false,snapshot.maxInstanceLifetime() != null ? snapshot.maxInstanceLifetime() : 0,snapshot.defaultInstanceWarmup() != null? snapshot.defaultInstanceWarmup()- : AsgOptionalFields.DEFAULT_INSTANCE_WARMUP_REMOVAL_SENTINEL+ : AsgOptionalFields.DEFAULT_INSTANCE_WARMUP_REMOVAL_SENTINEL,+ snapshot.serviceLinkedRoleArn(),+ snapshot.instanceMaintenancePolicy() != null+ ? snapshot.instanceMaintenancePolicy()+ : new InstanceMaintenancePolicy(InstanceMaintenancePolicy.REMOVAL_SENTINEL,+ InstanceMaintenancePolicy.REMOVAL_SENTINEL),+ snapshot.availabilityZoneDistribution(),+ snapshot.capacityReservationSpecification());autoScalingService.updateAutoScalingGroup(snapshot.region(),@@ -111,6 +125,10 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {snapshot.terminationPolicies(),optionalFields);+ clearUnsetSnapshotMembers(snapshot);+ if (snapshot.enabledMetrics() != null) {+ reconcileMetricsCollection(snapshot.region(), snapshot.name(), snapshot.enabledMetrics());+ }return true;} catch (Exception e) {LOG.errorv("Could not restore Auto Scaling group update snapshot for {0}: {1}",@@ -147,7 +165,12 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {String desiredCapacityType,Boolean capacityRebalance,Integer maxInstanceLifetime,- Integer defaultInstanceWarmup+ Integer defaultInstanceWarmup,+ String serviceLinkedRoleArn,+ InstanceMaintenancePolicy instanceMaintenancePolicy,+ AvailabilityZoneDistribution availabilityZoneDistribution,+ CapacityReservationSpecification capacityReservationSpecification,+ List<String> enabledMetrics) {}private static IllegalStateException unsupported(String resourceType) {@@ -224,6 +247,7 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {int healthCheckGracePeriod = parseIntProp(props, "HealthCheckGracePeriod", ctx, 0);List<String> terminationPolicies = ctx.resolveStringList(props, "TerminationPolicies");AsgOptionalFields optionalFields = resolveOptionalFields(props, ctx);+ List<String> metricsCollection = resolveMetricsCollection(props, ctx);// provision() re-runs on every UpdateStack, so a same-named group already on file must be// reconciled via UpdateAutoScalingGroup instead of re-created (createAutoScalingGroup throws@@ -252,7 +276,12 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {existing.getDesiredCapacityType(),existing.getCapacityRebalance(),existing.getMaxInstanceLifetime(),- existing.getDefaultInstanceWarmup()+ existing.getDefaultInstanceWarmup(),+ existing.getServiceLinkedRoleArn(),+ existing.getInstanceMaintenancePolicy(),+ existing.getAvailabilityZoneDistribution(),+ existing.getCapacityReservationSpecification(),+ existing.getEnabledMetrics() != null ? List.copyOf(existing.getEnabledMetrics()) : List.of());try {r.getAttributes().put(CfnRollback.ASG_UPDATE_SNAPSHOT_ATTR, MAPPER.writeValueAsString(snapshot));@@ -267,6 +296,9 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {mixedInstancesPolicy, minSize, maxSize, desiredCapacity, cooldown,availabilityZones, subnetIds, healthCheckType, healthCheckGracePeriod, terminationPolicies,optionalFields);+ if (metricsCollection != null) {+ reconcileMetricsCollection(region, name, metricsCollection);+ }asg = requireAutoScalingGroup(region, name);} else {asg = autoScalingService.createAutoScalingGroup(region, name,@@ -280,6 +312,10 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {resolveAsgTags(props, engine),resolveAsgTagPropagation(props, engine),optionalFields);+ if (metricsCollection != null && !metricsCollection.isEmpty()) {+ autoScalingService.enableMetricsCollection(region, name, metricsCollection,+ AutoScalingService.METRICS_GRANULARITY);+ }deleteRenamedResource(ctx, name, n -> autoScalingService.deleteAutoScalingGroup(region, n, true),"Auto Scaling group");}@@ -292,6 +328,25 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {r.getAttributes().put("Arn", asg.getAutoScalingGroupArn());}+ private void clearUnsetSnapshotMembers(AsgSnapshot snapshot) {+ if (snapshot.serviceLinkedRoleArn() != null+ && snapshot.availabilityZoneDistribution() != null+ && snapshot.capacityReservationSpecification() != null) {+ return;+ }+ AutoScalingGroup group = requireAutoScalingGroup(snapshot.region(), snapshot.name());+ if (snapshot.serviceLinkedRoleArn() == null) {+ group.setServiceLinkedRoleArn(null);+ }+ if (snapshot.availabilityZoneDistribution() == null) {+ group.setAvailabilityZoneDistribution(null);+ }+ if (snapshot.capacityReservationSpecification() == null) {+ group.setCapacityReservationSpecification(null);+ }+ autoScalingService.saveAutoScalingGroupIfPresent(group);+ }+private AutoScalingGroup requireAutoScalingGroup(String region, String name) {List<AutoScalingGroup> found = autoScalingService.describeAutoScalingGroups(region, List.of(name));if (found.isEmpty()) {@@ -301,10 +356,10 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {}/**- * The four group properties the schema defines that the CloudFormation path used to drop,- * passing {@code AsgOptionalFields.none()} instead. Absent stays null so an update overwrites- * only what the template set, which is what {@code AsgOptionalFields.applyToExistingGroup} and- * the Query handler's {@code UpdateAutoScalingGroup} both do.+ * The optional group properties the schema defines that Create/UpdateAutoScalingGroup also+ * carry. Absent stays null so an update overwrites only what the template set, which is what+ * {@code AsgOptionalFields.applyToExistingGroup} and the Query handler's+ * {@code UpdateAutoScalingGroup} both do.*/private AsgOptionalFields resolveOptionalFields(JsonNode props, ProvisionContext ctx) {String capacityRebalance = ctx.resolveOptional(props, "CapacityRebalance");@@ -314,7 +369,104 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {? null: Boolean.parseBoolean(capacityRebalance),parseOptionalInt("MaxInstanceLifetime", ctx.resolveOptional(props, "MaxInstanceLifetime")),- parseOptionalInt("DefaultInstanceWarmup", ctx.resolveOptional(props, "DefaultInstanceWarmup")));+ parseOptionalInt("DefaultInstanceWarmup", ctx.resolveOptional(props, "DefaultInstanceWarmup")),+ ctx.resolveOptional(props, "ServiceLinkedRoleARN"),+ resolveInstanceMaintenancePolicy(props, ctx),+ resolveAvailabilityZoneDistribution(props, ctx),+ resolveCapacityReservationSpecification(props, ctx));+ }++ private InstanceMaintenancePolicy resolveInstanceMaintenancePolicy(JsonNode props, ProvisionContext ctx) {+ JsonNode node = objectProperty(props, "InstanceMaintenancePolicy", ctx);+ if (node == null) {+ return null;+ }+ return new InstanceMaintenancePolicy(+ parseOptionalInt("MinHealthyPercentage", ctx.resolveOptional(node, "MinHealthyPercentage")),+ parseOptionalInt("MaxHealthyPercentage", ctx.resolveOptional(node, "MaxHealthyPercentage")));+ }++ private AvailabilityZoneDistribution resolveAvailabilityZoneDistribution(JsonNode props, ProvisionContext ctx) {+ JsonNode node = objectProperty(props, "AvailabilityZoneDistribution", ctx);+ if (node == null) {+ return null;+ }+ String strategy = blankToNull(ctx.resolveOptional(node, "CapacityDistributionStrategy"));+ return strategy != null ? new AvailabilityZoneDistribution(strategy) : null;+ }++ private CapacityReservationSpecification resolveCapacityReservationSpecification(JsonNode props,+ ProvisionContext ctx) {+ JsonNode node = objectProperty(props, "CapacityReservationSpecification", ctx);+ if (node == null) {+ return null;+ }+ String preference = blankToNull(ctx.resolveOptional(node, "CapacityReservationPreference"));+ if (preference == null) {+ throw new AwsException("ValidationError",+ "CapacityReservationSpecification requires CapacityReservationPreference.", 400);+ }+ CapacityReservationSpecification specification = new CapacityReservationSpecification();+ specification.setCapacityReservationPreference(preference);+ JsonNode target = objectProperty(node, "CapacityReservationTarget", ctx);+ if (target != null) {+ specification.setCapacityReservationIds(ctx.resolveStringList(target, "CapacityReservationIds"));+ specification.setCapacityReservationResourceGroupArns(+ ctx.resolveStringList(target, "CapacityReservationResourceGroupArns"));+ }+ return specification;+ }++ /**+ * The metric names that {@code MetricsCollection} enables, or {@code null} when the template+ * omits the property. The schema allows several entries. Their metric lists are merged, and an+ * entry naming no metrics stands for all of them, as it does on EnableMetricsCollection. The+ * schema requires {@code Granularity} on every entry.+ */+ private List<String> resolveMetricsCollection(JsonNode props, ProvisionContext ctx) {+ JsonNode node = props != null ? ctx.engine().resolveNode(props.get("MetricsCollection")) : null;+ if (node == null || !node.isArray()) {+ return null;+ }+ List<String> metrics = new ArrayList<>();+ for (JsonNode entry : node) {+ String granularity = blankToNull(ctx.resolveOptional(entry, "Granularity"));+ if (granularity == null) {+ throw new AwsException("ValidationError", "MetricsCollection requires Granularity.", 400);+ }+ if (!AutoScalingService.METRICS_GRANULARITY.equals(granularity)) {+ throw new AwsException("ValidationError", AutoScalingService.INVALID_GRANULARITY_MESSAGE, 400);+ }+ List<String> named = ctx.resolveStringList(entry, "Metrics");+ AutoScalingService.validateMetricNames(named);+ for (String metric : named.isEmpty() ? AutoScalingService.GROUP_METRICS : named) {+ if (!metrics.contains(metric)) {+ metrics.add(metric);+ }+ }+ }+ return metrics;+ }++ /**+ * Makes the group's enabled metrics exactly {@code desired}, so an empty list disables them all.+ * A template that drops {@code MetricsCollection} altogether never reaches here and leaves+ * collection untouched.+ */+ private void reconcileMetricsCollection(String region, String name, List<String> desired) {+ autoScalingService.disableMetricsCollection(region, name, List.of());+ if (!desired.isEmpty()) {+ autoScalingService.enableMetricsCollection(region, name, desired,+ AutoScalingService.METRICS_GRANULARITY);+ }+ }++ private JsonNode objectProperty(JsonNode props, String name, ProvisionContext ctx) {+ if (props == null || !props.has(name)) {+ return null;+ }+ JsonNode node = ctx.engine().resolveNode(props.get(name));+ return node != null && node.isObject() ? node : null;}/**@@ -348,6 +500,9 @@ public class AutoScalingGroupCfnProvisioner implements CfnResourceProvisioner {MixedInstancesPolicy.LaunchTemplateOverride override =new MixedInstancesPolicy.LaunchTemplateOverride();override.setInstanceType(instanceType);+ override.setWeightedCapacity(overrideNode.hasNonNull("WeightedCapacity")+ ? engine.resolve(overrideNode.get("WeightedCapacity"))+ : null);launchTemplate.getOverrides().add(override);}}diff --git a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingGroupOptionalStructuresIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingGroupOptionalStructuresIntegrationTest.javanew file mode 100644index 0000000000..d841e80b44--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingGroupOptionalStructuresIntegrationTest.java@@ -0,0 +1,400 @@+package io.github.hectorvent.floci.services.autoscaling;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;++/**+ * Wire-level coverage for the AutoScalingGroup members that DescribeAutoScalingGroups used to drop:+ * ServiceLinkedRoleARN, InstanceMaintenancePolicy, AvailabilityZoneDistribution,+ * CapacityReservationSpecification, a mixed instances policy override's WeightedCapacity, and+ * EnabledMetrics, which only EnableMetricsCollection and DisableMetricsCollection set.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class AutoScalingGroupOptionalStructuresIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260501/us-east-1/autoscaling/aws4_request";+ private static final String EC2_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260501/us-east-1/ec2/aws4_request";++ private static final String GROUP = "opt-structures-asg";+ private static final String BARE_GROUP = "opt-structures-bare-asg";+ private static final String MEMBER =+ "DescribeAutoScalingGroupsResponse.DescribeAutoScalingGroupsResult.AutoScalingGroups.member.";+ private static final String ROLE_ARN =+ "arn:aws:iam::000000000000:role/aws-service-role/autoscaling.amazonaws.com/AWSServiceRoleForAutoScaling_opt";++ private static String launchTemplateId;++ @Test+ @Order(1)+ void createRoundTripsEveryOptionalStructure() {+ launchTemplateId = given()+ .formParam("Action", "CreateLaunchTemplate")+ .formParam("LaunchTemplateName", "opt-structures-lt")+ .formParam("LaunchTemplateData.ImageId", "ami-12345678")+ .formParam("LaunchTemplateData.InstanceType", "t3.micro")+ .header("Authorization", EC2_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateLaunchTemplateResponse.launchTemplate.launchTemplateId");++ given()+ .formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", GROUP)+ .formParam("MinSize", "0")+ .formParam("MaxSize", "6")+ .formParam("DesiredCapacity", "0")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .formParam("MixedInstancesPolicy.LaunchTemplate.LaunchTemplateSpecification.LaunchTemplateId",+ launchTemplateId)+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.1.InstanceType", "t3.micro")+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.1.WeightedCapacity", "2")+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.2.InstanceType", "t3.small")+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.2.WeightedCapacity", "4")+ .formParam("ServiceLinkedRoleARN", ROLE_ARN)+ .formParam("InstanceMaintenancePolicy.MinHealthyPercentage", "100")+ .formParam("InstanceMaintenancePolicy.MaxHealthyPercentage", "110")+ .formParam("AvailabilityZoneDistribution.CapacityDistributionStrategy", "balanced-only")+ .formParam("CapacityReservationSpecification.CapacityReservationPreference",+ "capacity-reservations-only")+ .formParam("CapacityReservationSpecification.CapacityReservationTarget"+ + ".CapacityReservationIds.member.1", "cr-0123456789abcdef0")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ describe(GROUP)+ .body(MEMBER + "ServiceLinkedRoleARN", equalTo(ROLE_ARN))+ .body(MEMBER + "InstanceMaintenancePolicy.MinHealthyPercentage", equalTo("100"))+ .body(MEMBER + "InstanceMaintenancePolicy.MaxHealthyPercentage", equalTo("110"))+ .body(MEMBER + "AvailabilityZoneDistribution.CapacityDistributionStrategy",+ equalTo("balanced-only"))+ .body(MEMBER + "CapacityReservationSpecification.CapacityReservationPreference",+ equalTo("capacity-reservations-only"))+ .body(MEMBER + "CapacityReservationSpecification.CapacityReservationTarget"+ + ".CapacityReservationIds.member", equalTo("cr-0123456789abcdef0"))+ .body(MEMBER + "MixedInstancesPolicy.LaunchTemplate.Overrides.member[0].WeightedCapacity",+ equalTo("2"))+ .body(MEMBER + "MixedInstancesPolicy.LaunchTemplate.Overrides.member[1].WeightedCapacity",+ equalTo("4"));+ }++ @Test+ @Order(2)+ void updateOverwritesOnlyTheStructuresTheRequestCarries() {+ given()+ .formParam("Action", "UpdateAutoScalingGroup")+ .formParam("AutoScalingGroupName", GROUP)+ .formParam("AvailabilityZoneDistribution.CapacityDistributionStrategy", "balanced-best-effort")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ describe(GROUP)+ .body(MEMBER + "AvailabilityZoneDistribution.CapacityDistributionStrategy",+ equalTo("balanced-best-effort"))+ .body(MEMBER + "ServiceLinkedRoleARN", equalTo(ROLE_ARN))+ .body(MEMBER + "InstanceMaintenancePolicy.MinHealthyPercentage", equalTo("100"))+ .body(MEMBER + "CapacityReservationSpecification.CapacityReservationPreference",+ equalTo("capacity-reservations-only"));+ }++ @Test+ @Order(3)+ void instanceMaintenancePolicyMinusOneOnBothClearsIt() {+ given()+ .formParam("Action", "UpdateAutoScalingGroup")+ .formParam("AutoScalingGroupName", GROUP)+ .formParam("InstanceMaintenancePolicy.MinHealthyPercentage", "-1")+ .formParam("InstanceMaintenancePolicy.MaxHealthyPercentage", "-1")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ describe(GROUP)+ .body(not(containsString("<InstanceMaintenancePolicy>")))+ .body(MEMBER + "ServiceLinkedRoleARN", equalTo(ROLE_ARN));+ }++ @Test+ @Order(4)+ void enableAndDisableMetricsCollectionRoundTripEnabledMetrics() {+ given()+ .formParam("Action", "EnableMetricsCollection")+ .formParam("AutoScalingGroupName", GROUP)+ .formParam("Metrics.member.1", "GroupMinSize")+ .formParam("Metrics.member.2", "GroupMaxSize")+ .formParam("Granularity", "1Minute")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("EnableMetricsCollectionResponse"));++ describe(GROUP)+ .body(MEMBER + "EnabledMetrics.member[0].Metric", equalTo("GroupMinSize"))+ .body(MEMBER + "EnabledMetrics.member[0].Granularity", equalTo("1Minute"))+ .body(MEMBER + "EnabledMetrics.member[1].Metric", equalTo("GroupMaxSize"));++ given()+ .formParam("Action", "DisableMetricsCollection")+ .formParam("AutoScalingGroupName", GROUP)+ .formParam("Metrics.member.1", "GroupMinSize")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("DisableMetricsCollectionResponse"));++ describe(GROUP)+ .body(MEMBER + "EnabledMetrics.member.Metric", equalTo("GroupMaxSize"))+ .body(not(containsString("<Metric>GroupMinSize</Metric>")));++ given()+ .formParam("Action", "DisableMetricsCollection")+ .formParam("AutoScalingGroupName", GROUP)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ describe(GROUP).body(not(containsString("<EnabledMetrics>")));+ }++ @Test+ @Order(5)+ void enableMetricsCollectionWithNoMetricsEnablesAllOfThem() {+ given()+ .formParam("Action", "EnableMetricsCollection")+ .formParam("AutoScalingGroupName", GROUP)+ .formParam("Granularity", "1Minute")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ describe(GROUP)+ .body(containsString("<Metric>GroupTotalInstances</Metric>"))+ .body(containsString("<Metric>GroupAndWarmPoolTotalCapacity</Metric>"));+ }++ @Test+ @Order(6)+ void enableMetricsCollectionRejectsAGranularityOtherThanOneMinute() {+ given()+ .formParam("Action", "EnableMetricsCollection")+ .formParam("AutoScalingGroupName", GROUP)+ .formParam("Granularity", "5Minute")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body(containsString("ValidationError"))+ .body(containsString("1Minute"));+ }++ @Test+ @Order(7)+ void aGroupThatSetsNoneOfThemOmitsThemFromDescribe() {+ given()+ .formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", BARE_GROUP)+ .formParam("LaunchTemplate.LaunchTemplateId", launchTemplateId)+ .formParam("MinSize", "0")+ .formParam("MaxSize", "1")+ .formParam("DesiredCapacity", "0")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ describe(BARE_GROUP)+ .body(not(containsString("<ServiceLinkedRoleARN>")))+ .body(not(containsString("<InstanceMaintenancePolicy>")))+ .body(not(containsString("<AvailabilityZoneDistribution>")))+ .body(not(containsString("<CapacityReservationSpecification>")))+ .body(not(containsString("<EnabledMetrics>")));+ }++ @Test+ @Order(8)+ void createRejectsAMaxHealthyPercentageBelowOneHundred() {+ rejectedCreate("opt-structures-bad-max",+ "InstanceMaintenancePolicy.MinHealthyPercentage", "50",+ "InstanceMaintenancePolicy.MaxHealthyPercentage", "90")+ .body(containsString("MaxHealthyPercentage"));+ }++ @Test+ @Order(9)+ void createRejectsAHealthyPercentageSpreadAboveOneHundred() {+ rejectedCreate("opt-structures-wide-spread",+ "InstanceMaintenancePolicy.MinHealthyPercentage", "0",+ "InstanceMaintenancePolicy.MaxHealthyPercentage", "150")+ .body(containsString("cannot be greater than 100"));+ }++ @Test+ @Order(10)+ void createRejectsAnInstanceMaintenancePolicyMissingOnePercentage() {+ rejectedCreate("opt-structures-half-policy",+ "InstanceMaintenancePolicy.MinHealthyPercentage", "90",+ "DesiredCapacity", "0")+ .body(containsString("Both MinHealthyPercentage and MaxHealthyPercentage"));+ }++ @Test+ @Order(11)+ void createRejectsAnUnknownCapacityDistributionStrategy() {+ rejectedCreate("opt-structures-bad-strategy",+ "AvailabilityZoneDistribution.CapacityDistributionStrategy", "round-robin",+ "DesiredCapacity", "0")+ .body(containsString("CapacityDistributionStrategy"));+ }++ @Test+ @Order(12)+ void createRejectsAnUnknownCapacityReservationPreference() {+ rejectedCreate("opt-structures-bad-preference",+ "CapacityReservationSpecification.CapacityReservationPreference", "open",+ "DesiredCapacity", "0")+ .body(containsString("CapacityReservationPreference"));+ }++ @Test+ @Order(13)+ void createRejectsAWeightedCapacityOutsideOneTo999() {+ given()+ .formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", "opt-structures-bad-weight")+ .formParam("MinSize", "0")+ .formParam("MaxSize", "1")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .formParam("MixedInstancesPolicy.LaunchTemplate.LaunchTemplateSpecification.LaunchTemplateId",+ launchTemplateId)+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.1.InstanceType", "t3.micro")+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.1.WeightedCapacity", "1000")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body(containsString("ValidationError"))+ .body(containsString("WeightedCapacity"));+ }++ @Test+ @Order(14)+ void createRejectsAWeightedCapacityOnOnlySomeOverrides() {+ given()+ .formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", "opt-structures-partial-weight")+ .formParam("MinSize", "0")+ .formParam("MaxSize", "1")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .formParam("MixedInstancesPolicy.LaunchTemplate.LaunchTemplateSpecification.LaunchTemplateId",+ launchTemplateId)+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.1.InstanceType", "t3.micro")+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.1.WeightedCapacity", "1")+ .formParam("MixedInstancesPolicy.LaunchTemplate.Overrides.member.2.InstanceType", "t3.small")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body(containsString("ValidationError"))+ .body(containsString("for all of them"));+ }++ @Test+ @Order(15)+ void createRejectsACapacityReservationTargetWithPreferenceNone() {+ rejectedCreate("opt-structures-none-target",+ "CapacityReservationSpecification.CapacityReservationPreference", "none",+ "CapacityReservationSpecification.CapacityReservationTarget.CapacityReservationIds.member.1",+ "cr-0123456789abcdef0")+ .body(containsString("CapacityReservationTarget"));+ }++ @Test+ @Order(16)+ void createRejectsACapacityReservationIdOutsideItsPattern() {+ rejectedCreate("opt-structures-bad-reservation-id",+ "CapacityReservationSpecification.CapacityReservationPreference", "capacity-reservations-only",+ "CapacityReservationSpecification.CapacityReservationTarget.CapacityReservationIds.member.1",+ "cr 0123")+ .body(containsString("capacityReservationIds"));+ }++ @Test+ @Order(17)+ void cleanUp() {+ for (String name : new String[] {GROUP, BARE_GROUP}) {+ given()+ .formParam("Action", "DeleteAutoScalingGroup")+ .formParam("AutoScalingGroupName", name)+ .formParam("ForceDelete", "true")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }+ }++ private static ValidatableResponse rejectedCreate(String name, String key1, String value1,+ String key2, String value2) {+ return given()+ .formParam("Action", "CreateAutoScalingGroup")+ .formParam("AutoScalingGroupName", name)+ .formParam("LaunchTemplate.LaunchTemplateId", launchTemplateId)+ .formParam("MinSize", "0")+ .formParam("MaxSize", "1")+ .formParam("AvailabilityZones.member.1", "us-east-1a")+ .formParam(key1, value1)+ .formParam(key2, value2)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body(containsString("ValidationError"));+ }++ private static ValidatableResponse describe(String name) {+ return given()+ .formParam("Action", "DescribeAutoScalingGroups")+ .formParam("AutoScalingGroupNames.member.1", name)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }+}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.javaindex 80b8ef5698..542825d4c8 100644--- a/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/autoscaling/AutoScalingServiceTest.java@@ -5,6 +5,9 @@ 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.AsgOptionalFields;import io.github.hectorvent.floci.services.autoscaling.model.AutoScalingGroup;+import io.github.hectorvent.floci.services.autoscaling.model.AvailabilityZoneDistribution;+import io.github.hectorvent.floci.services.autoscaling.model.CapacityReservationSpecification;+import io.github.hectorvent.floci.services.autoscaling.model.InstanceMaintenancePolicy;import io.github.hectorvent.floci.services.autoscaling.model.InstanceRefresh;import io.github.hectorvent.floci.services.autoscaling.model.LaunchConfiguration;import io.github.hectorvent.floci.services.autoscaling.model.LaunchConfigurationBlockDeviceMapping;@@ -1217,6 +1220,205 @@ class AutoScalingServiceTest {assertEquals(AutoScalingService.INSTANCE_REQUIREMENTS_MISSING_RANGES_MESSAGE, error.getMessage());}+ @Test+ void createAndUpdateCarryTheOptionalStructuresAndUpdateLeavesUnsetOnesAlone() {+ CapacityReservationSpecification reservation = new CapacityReservationSpecification();+ reservation.setCapacityReservationPreference("capacity-reservations-first");+ reservation.setCapacityReservationResourceGroupArns(List.of("arn:aws:resource-groups:us-east-1:000000000000:group/cr"));+ createWithStructures("structures-asg", new AsgOptionalFields(null, null, null, null,+ "role-arn", new InstanceMaintenancePolicy(90, 120),+ new AvailabilityZoneDistribution("balanced-only"), reservation));++ service.updateAutoScalingGroup(REGION, "structures-asg", null, null, null, null, null,+ null, null, null, null, null, null, null, null, null,+ new AsgOptionalFields(null, null, null, null, "other-role-arn", null, null, null));++ AutoScalingGroup group = service.describeAutoScalingGroups(REGION, List.of("structures-asg")).getFirst();+ assertEquals("other-role-arn", group.getServiceLinkedRoleArn());+ assertEquals(90, group.getInstanceMaintenancePolicy().getMinHealthyPercentage());+ assertEquals(120, group.getInstanceMaintenancePolicy().getMaxHealthyPercentage());+ assertEquals("balanced-only", group.getAvailabilityZoneDistribution().getCapacityDistributionStrategy());+ assertEquals("capacity-reservations-first",+ group.getCapacityReservationSpecification().getCapacityReservationPreference());+ }++ @Test+ void instanceMaintenancePolicyRemovalSentinelClearsTheStoredPolicy() {+ createWithStructures("maintenance-asg", new AsgOptionalFields(null, null, null, null,+ null, new InstanceMaintenancePolicy(100, 110), null, null));++ service.updateAutoScalingGroup(REGION, "maintenance-asg", null, null, null, null, null,+ null, null, null, null, null, null, null, null, null,+ new AsgOptionalFields(null, null, null, null, null,+ new InstanceMaintenancePolicy(-1, -1), null, null));++ assertNull(service.describeAutoScalingGroups(REGION, List.of("maintenance-asg"))+ .getFirst().getInstanceMaintenancePolicy());+ }++ @Test+ void instanceMaintenancePolicyEnforcesTheModelBounds() {+ assertMaintenancePolicyRejected(null, 110, AutoScalingService.INSTANCE_MAINTENANCE_POLICY_BOTH_REQUIRED_MESSAGE);+ assertMaintenancePolicyRejected(-1, 110, AutoScalingService.INSTANCE_MAINTENANCE_POLICY_PARTIAL_CLEAR_MESSAGE);+ assertMaintenancePolicyRejected(101, 150, AutoScalingService.INVALID_MIN_HEALTHY_PERCENTAGE_MESSAGE);+ assertMaintenancePolicyRejected(50, 99, AutoScalingService.INVALID_MAX_HEALTHY_PERCENTAGE_MESSAGE);+ assertMaintenancePolicyRejected(50, 201, AutoScalingService.INVALID_MAX_HEALTHY_PERCENTAGE_MESSAGE);+ assertMaintenancePolicyRejected(0, 101, AutoScalingService.INSTANCE_MAINTENANCE_POLICY_RANGE_MESSAGE);++ createWithStructures("maintenance-bounds-asg", new AsgOptionalFields(null, null, null, null,+ null, new InstanceMaintenancePolicy(0, 100), null, null));+ assertEquals(0, service.describeAutoScalingGroups(REGION, List.of("maintenance-bounds-asg"))+ .getFirst().getInstanceMaintenancePolicy().getMinHealthyPercentage());+ }++ @Test+ void capacityStructuresRejectValuesOutsideTheirEnums() {+ AwsException strategy = assertThrows(AwsException.class, () -> createWithStructures("bad-strategy-asg",+ new AsgOptionalFields(null, null, null, null, null, null,+ new AvailabilityZoneDistribution("round-robin"), null)));+ assertEquals(AutoScalingService.INVALID_CAPACITY_DISTRIBUTION_STRATEGY_MESSAGE, strategy.getMessage());++ CapacityReservationSpecification badPreference = new CapacityReservationSpecification();+ badPreference.setCapacityReservationPreference("open");+ AwsException preference = assertThrows(AwsException.class, () -> createWithStructures("bad-preference-asg",+ new AsgOptionalFields(null, null, null, null, null, null, null, badPreference)));+ assertEquals(AutoScalingService.INVALID_CAPACITY_RESERVATION_PREFERENCE_MESSAGE, preference.getMessage());+ }++ @Test+ void capacityReservationPreferenceNoneRejectsATarget() {+ CapacityReservationSpecification specification = new CapacityReservationSpecification();+ specification.setCapacityReservationPreference("none");+ specification.setCapacityReservationIds(List.of("cr-0123456789abcdef0"));++ AwsException error = assertThrows(AwsException.class, () -> createWithStructures("none-target-asg",+ new AsgOptionalFields(null, null, null, null, null, null, null, specification)));++ assertEquals(AutoScalingService.CAPACITY_RESERVATION_TARGET_WITH_NONE_MESSAGE, error.getMessage());+ }++ @Test+ void capacityReservationTargetMembersFollowTheirModelShapes() {+ CapacityReservationSpecification badId = new CapacityReservationSpecification();+ badId.setCapacityReservationPreference("capacity-reservations-only");+ badId.setCapacityReservationIds(List.of("cr 0123"));+ AwsException idError = assertThrows(AwsException.class, () -> createWithStructures("bad-id-asg",+ new AsgOptionalFields(null, null, null, null, null, null, null, badId)));+ assertEquals("ValidationError", idError.getErrorCode());++ CapacityReservationSpecification longId = new CapacityReservationSpecification();+ longId.setCapacityReservationPreference("capacity-reservations-only");+ longId.setCapacityReservationIds(List.of("c".repeat(256)));+ assertThrows(AwsException.class, () -> createWithStructures("long-id-asg",+ new AsgOptionalFields(null, null, null, null, null, null, null, longId)));++ CapacityReservationSpecification longArn = new CapacityReservationSpecification();+ longArn.setCapacityReservationPreference("capacity-reservations-only");+ longArn.setCapacityReservationResourceGroupArns(List.of("a".repeat(1601)));+ assertThrows(AwsException.class, () -> createWithStructures("long-arn-asg",+ new AsgOptionalFields(null, null, null, null, null, null, null, longArn)));+ }++ @Test+ void serviceLinkedRoleArnMustBeOneTo1600Characters() {+ AwsException empty = assertThrows(AwsException.class, () -> createWithStructures("empty-role-asg",+ new AsgOptionalFields(null, null, null, null, "", null, null, null)));+ assertEquals(AutoScalingService.INVALID_SERVICE_LINKED_ROLE_ARN_MESSAGE, empty.getMessage());++ AwsException tooLong = assertThrows(AwsException.class, () -> createWithStructures("long-role-asg",+ new AsgOptionalFields(null, null, null, null, "a".repeat(1601), null, null, null)));+ assertEquals(AutoScalingService.INVALID_SERVICE_LINKED_ROLE_ARN_MESSAGE, tooLong.getMessage());+ }++ @Test+ void weightedCapacityMustBeOneTo999AndSetOnEveryOverrideOrNone() {+ AwsException outOfRange = assertThrows(AwsException.class, () -> createWithStructures("weight-range-asg",+ AsgOptionalFields.none(), weightedPolicy("0", "2")));+ assertEquals(AutoScalingService.INVALID_WEIGHTED_CAPACITY_MESSAGE, outOfRange.getMessage());++ AwsException notANumber = assertThrows(AwsException.class, () -> createWithStructures("weight-text-asg",+ AsgOptionalFields.none(), weightedPolicy("two", "2")));+ assertEquals(AutoScalingService.INVALID_WEIGHTED_CAPACITY_MESSAGE, notANumber.getMessage());++ AwsException tooLong = assertThrows(AwsException.class, () -> createWithStructures("weight-long-asg",+ AsgOptionalFields.none(), weightedPolicy("0".repeat(32) + "1", "2")));+ assertEquals(AutoScalingService.INVALID_WEIGHTED_CAPACITY_MESSAGE, tooLong.getMessage());++ AwsException partial = assertThrows(AwsException.class, () -> createWithStructures("weight-partial-asg",+ AsgOptionalFields.none(), weightedPolicy("2", null)));+ assertEquals(AutoScalingService.PARTIAL_WEIGHTED_CAPACITY_MESSAGE, partial.getMessage());++ createWithStructures("weight-ok-asg", AsgOptionalFields.none(), weightedPolicy("1", "999"));+ assertEquals("999", service.describeAutoScalingGroups(REGION, List.of("weight-ok-asg")).getFirst()+ .getMixedInstancesPolicy().getLaunchTemplate().getOverrides().get(1).getWeightedCapacity());+ }++ @Test+ void enableAndDisableMetricsCollectionMaintainEnabledMetrics() {+ service.enableMetricsCollection(REGION, "test-asg", List.of("GroupMinSize", "GroupMaxSize"), "1Minute");+ service.enableMetricsCollection(REGION, "test-asg", List.of("GroupMaxSize", "GroupTotalInstances"), "1Minute");+ assertEquals(List.of("GroupMinSize", "GroupMaxSize", "GroupTotalInstances"), enabledMetrics());++ service.disableMetricsCollection(REGION, "test-asg", List.of("GroupMaxSize"));+ assertEquals(List.of("GroupMinSize", "GroupTotalInstances"), enabledMetrics());++ service.disableMetricsCollection(REGION, "test-asg", List.of());+ assertEquals(List.of(), enabledMetrics());++ service.enableMetricsCollection(REGION, "test-asg", List.of(), "1Minute");+ assertEquals(AutoScalingService.GROUP_METRICS, enabledMetrics());+ }++ @Test+ void enableMetricsCollectionRequiresOneMinuteGranularityAndKnownMetrics() {+ AwsException missing = assertThrows(AwsException.class,+ () -> service.enableMetricsCollection(REGION, "test-asg", List.of(), null));+ assertEquals(AutoScalingService.MISSING_GRANULARITY_MESSAGE, missing.getMessage());++ AwsException wrong = assertThrows(AwsException.class,+ () -> service.enableMetricsCollection(REGION, "test-asg", List.of(), "5Minute"));+ assertEquals(AutoScalingService.INVALID_GRANULARITY_MESSAGE, wrong.getMessage());++ AwsException unknown = assertThrows(AwsException.class,+ () -> service.enableMetricsCollection(REGION, "test-asg", List.of("CPUUtilization"), "1Minute"));+ assertEquals("ValidationError", unknown.getErrorCode());+ assertEquals(List.of(), enabledMetrics());+ }++ private List<String> enabledMetrics() {+ return service.describeAutoScalingGroups(REGION, List.of("test-asg")).getFirst().getEnabledMetrics();+ }++ private void assertMaintenancePolicyRejected(Integer min, Integer max, String message) {+ AwsException error = assertThrows(AwsException.class, () -> createWithStructures("maintenance-bad-asg",+ new AsgOptionalFields(null, null, null, null, null,+ new InstanceMaintenancePolicy(min, max), null, null)));+ assertEquals("ValidationError", error.getErrorCode());+ assertEquals(message, error.getMessage());+ }++ private void createWithStructures(String name, AsgOptionalFields optionalFields) {+ service.createAutoScalingGroup(REGION, name, null, "lt-original", null, "1", null,+ 0, 3, 1, 300, List.of("us-east-1a"), List.of(), List.of(), List.of(), "EC2", 0,+ List.of("Default"), Map.of(), Map.of(), optionalFields);+ }++ private void createWithStructures(String name, AsgOptionalFields optionalFields, MixedInstancesPolicy policy) {+ service.createAutoScalingGroup(REGION, name, null, null, null, null, policy,+ 0, 3, 1, 300, List.of("us-east-1a"), List.of(), List.of(), List.of(), "EC2", 0,+ List.of("Default"), Map.of(), Map.of(), optionalFields);+ }++ private static MixedInstancesPolicy weightedPolicy(String firstWeight, String secondWeight) {+ MixedInstancesPolicy.LaunchTemplateOverride first = new MixedInstancesPolicy.LaunchTemplateOverride();+ first.setInstanceType("t3.micro");+ first.setWeightedCapacity(firstWeight);+ MixedInstancesPolicy.LaunchTemplateOverride second = new MixedInstancesPolicy.LaunchTemplateOverride();+ second.setInstanceType("t3.small");+ second.setWeightedCapacity(secondWeight);+ return policyWithOverrides(List.of(first, second));+ }+private static MixedInstancesPolicy attributeBasedPolicy(int minVCpuCount, int minMemoryMiB) {MixedInstancesPolicy.InstanceRequirements requirements = new MixedInstancesPolicy.InstanceRequirements();requirements.setVCpuCount(intRange(minVCpuCount));diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationAutoScalingIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationAutoScalingIntegrationTest.javaindex 0668dabcee..4e46aa3299 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationAutoScalingIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationAutoScalingIntegrationTest.java@@ -52,6 +52,11 @@ class CloudFormationAutoScalingIntegrationTest {"CapacityRebalance": true,"MaxInstanceLifetime": 86400,"DefaultInstanceWarmup": 300,+ "ServiceLinkedRoleARN": "arn:aws:iam::000000000000:role/aws-service-role/autoscaling.amazonaws.com/AWSServiceRoleForAutoScaling_cfn",+ "InstanceMaintenancePolicy": {"MinHealthyPercentage": 90, "MaxHealthyPercentage": 120},+ "AvailabilityZoneDistribution": {"CapacityDistributionStrategy": "balanced-only"},+ "CapacityReservationSpecification": {"CapacityReservationPreference": "none"},+ "MetricsCollection": [{"Granularity": "1Minute", "Metrics": ["GroupMinSize", "GroupMaxSize"]}],"Tags": [{"Key": "cluster", "Value": "demo", "PropagateAtLaunch": true},{"Key": "control-plane", "Value": "only", "PropagateAtLaunch": false}@@ -119,7 +124,17 @@ class CloudFormationAutoScalingIntegrationTest {.body(containsString("<DesiredCapacityType>units</DesiredCapacityType>")).body(containsString("<CapacityRebalance>true</CapacityRebalance>")).body(containsString("<MaxInstanceLifetime>86400</MaxInstanceLifetime>"))- .body(containsString("<DefaultInstanceWarmup>300</DefaultInstanceWarmup>"));+ .body(containsString("<DefaultInstanceWarmup>300</DefaultInstanceWarmup>"))+ .body(containsString("<ServiceLinkedRoleARN>arn:aws:iam::000000000000:role/aws-service-role/"+ + "autoscaling.amazonaws.com/AWSServiceRoleForAutoScaling_cfn</ServiceLinkedRoleARN>"))+ .body(containsString("<InstanceMaintenancePolicy><MinHealthyPercentage>90</MinHealthyPercentage>"+ + "<MaxHealthyPercentage>120</MaxHealthyPercentage></InstanceMaintenancePolicy>"))+ .body(containsString("<AvailabilityZoneDistribution><CapacityDistributionStrategy>balanced-only"+ + "</CapacityDistributionStrategy></AvailabilityZoneDistribution>"))+ .body(containsString("<CapacityReservationSpecification><CapacityReservationPreference>none"+ + "</CapacityReservationPreference></CapacityReservationSpecification>"))+ .body(containsString("<member><Metric>GroupMinSize</Metric><Granularity>1Minute</Granularity></member>"))+ .body(containsString("<member><Metric>GroupMaxSize</Metric><Granularity>1Minute</Granularity></member>"));}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisionerTest.javaindex 839632cf09..fecf00f3c2 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/AutoScalingGroupCfnProvisionerTest.java@@ -3,10 +3,15 @@ package io.github.hectorvent.floci.services.cloudformation.provisioners;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.autoscaling.AutoScalingService;import io.github.hectorvent.floci.services.autoscaling.model.AsgOptionalFields;import io.github.hectorvent.floci.services.autoscaling.model.AutoScalingGroup;+import io.github.hectorvent.floci.services.autoscaling.model.AvailabilityZoneDistribution;+import io.github.hectorvent.floci.services.autoscaling.model.CapacityReservationSpecification;+import io.github.hectorvent.floci.services.autoscaling.model.InstanceMaintenancePolicy;import io.github.hectorvent.floci.services.autoscaling.model.LaunchConfiguration;+import io.github.hectorvent.floci.services.autoscaling.model.MixedInstancesPolicy;import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;import io.github.hectorvent.floci.services.cloudformation.model.StackResource;import org.junit.jupiter.api.Test;@@ -168,6 +173,131 @@ class AutoScalingGroupCfnProvisionerTest {assertNull(optional.defaultInstanceWarmup());}+ @Test+ void groupCreateCarriesTheOptionalStructuresAndMetricsCollection() {+ when(autoScaling.createAutoScalingGroup(eq(REGION), eq("my-asg"), any(), any(), any(), any(),+ any(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(), anyList(),+ any(), anyInt(), anyList(), anyMap(), anyMap(), any()))+ .thenReturn(group("my-asg"));+ StackResource r = resource(GROUP, "Asg", null);+ ObjectNode props = mapper.createObjectNode()+ .put("AutoScalingGroupName", "my-asg")+ .put("MinSize", "1")+ .put("MaxSize", "3")+ .put("ServiceLinkedRoleARN", "role-arn");+ props.putObject("InstanceMaintenancePolicy")+ .put("MinHealthyPercentage", 90)+ .put("MaxHealthyPercentage", 120);+ props.putObject("AvailabilityZoneDistribution").put("CapacityDistributionStrategy", "balanced-only");+ ObjectNode reservation = props.putObject("CapacityReservationSpecification")+ .put("CapacityReservationPreference", "capacity-reservations-only");+ reservation.putObject("CapacityReservationTarget").putArray("CapacityReservationIds").add("cr-1");+ ObjectNode metrics = props.putArray("MetricsCollection").addObject().put("Granularity", "1Minute");+ metrics.putArray("Metrics").add("GroupMinSize").add("GroupMaxSize");+ ObjectNode launchTemplate = props.putObject("MixedInstancesPolicy").putObject("LaunchTemplate");+ launchTemplate.putObject("LaunchTemplateSpecification").put("LaunchTemplateId", "lt-123");+ launchTemplate.putArray("Overrides").addObject()+ .put("InstanceType", "t3.micro")+ .put("WeightedCapacity", "2");++ provisioner.provision(r, props, ctx());++ ArgumentCaptor<MixedInstancesPolicy> policyCaptor = ArgumentCaptor.forClass(MixedInstancesPolicy.class);+ ArgumentCaptor<AsgOptionalFields> captor = ArgumentCaptor.forClass(AsgOptionalFields.class);+ verify(autoScaling).createAutoScalingGroup(eq(REGION), eq("my-asg"), any(), any(), any(), any(),+ policyCaptor.capture(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(),+ anyList(), any(), anyInt(), anyList(), anyMap(), anyMap(), captor.capture());+ AsgOptionalFields optional = captor.getValue();+ assertEquals("role-arn", optional.serviceLinkedRoleArn());+ assertEquals(90, optional.instanceMaintenancePolicy().getMinHealthyPercentage());+ assertEquals(120, optional.instanceMaintenancePolicy().getMaxHealthyPercentage());+ assertEquals("balanced-only", optional.availabilityZoneDistribution().getCapacityDistributionStrategy());+ assertEquals("capacity-reservations-only",+ optional.capacityReservationSpecification().getCapacityReservationPreference());+ assertEquals(List.of("cr-1"), optional.capacityReservationSpecification().getCapacityReservationIds());+ assertEquals("2", policyCaptor.getValue().getLaunchTemplate().getOverrides().getFirst().getWeightedCapacity());+ verify(autoScaling).enableMetricsCollection(REGION, "my-asg", List.of("GroupMinSize", "GroupMaxSize"), "1Minute");+ }++ @Test+ void groupCreateLeavesTheOptionalStructuresNullAndMetricsAloneWhenTheTemplateOmitsThem() {+ when(autoScaling.createAutoScalingGroup(eq(REGION), eq("my-asg"), any(), any(), any(), any(),+ any(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(), anyList(),+ any(), anyInt(), anyList(), anyMap(), anyMap(), any()))+ .thenReturn(group("my-asg"));+ StackResource r = resource(GROUP, "Asg", null);+ ObjectNode props = mapper.createObjectNode().put("AutoScalingGroupName", "my-asg");++ provisioner.provision(r, props, ctx());++ ArgumentCaptor<AsgOptionalFields> captor = ArgumentCaptor.forClass(AsgOptionalFields.class);+ verify(autoScaling).createAutoScalingGroup(eq(REGION), eq("my-asg"), any(), any(), any(), any(),+ any(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(), anyList(),+ any(), anyInt(), anyList(), anyMap(), anyMap(), captor.capture());+ AsgOptionalFields optional = captor.getValue();+ assertNull(optional.serviceLinkedRoleArn());+ assertNull(optional.instanceMaintenancePolicy());+ assertNull(optional.availabilityZoneDistribution());+ assertNull(optional.capacityReservationSpecification());+ verify(autoScaling, never()).enableMetricsCollection(anyString(), anyString(), anyList(), anyString());+ }++ @Test+ void groupCreateRejectsAMetricsCollectionEntryWithoutGranularity() {+ StackResource r = resource(GROUP, "Asg", null);+ ObjectNode props = mapper.createObjectNode().put("AutoScalingGroupName", "my-asg");+ props.putArray("MetricsCollection").addObject().putArray("Metrics").add("GroupMinSize");++ AwsException error = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx()));++ assertEquals("ValidationError", error.getErrorCode());+ verify(autoScaling, never()).createAutoScalingGroup(any(), any(), any(), any(), any(), any(),+ any(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(), anyList(),+ any(), anyInt(), anyList(), anyMap(), anyMap(), any());+ }++ @Test+ void groupCreateRejectsAnUnknownMetricBeforeCreatingTheGroup() {+ StackResource r = resource(GROUP, "Asg", null);+ ObjectNode props = mapper.createObjectNode().put("AutoScalingGroupName", "my-asg");+ props.putArray("MetricsCollection").addObject().put("Granularity", "1Minute")+ .putArray("Metrics").add("CPUUtilization");++ AwsException error = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx()));++ assertEquals("ValidationError", error.getErrorCode());+ verify(autoScaling, never()).createAutoScalingGroup(any(), any(), any(), any(), any(), any(),+ any(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(), anyList(),+ any(), anyInt(), anyList(), anyMap(), anyMap(), any());+ }++ @Test+ void groupCreateRejectsACapacityReservationSpecificationWithoutPreference() {+ StackResource r = resource(GROUP, "Asg", null);+ ObjectNode props = mapper.createObjectNode().put("AutoScalingGroupName", "my-asg");+ props.putObject("CapacityReservationSpecification").putObject("CapacityReservationTarget")+ .putArray("CapacityReservationIds").add("cr-1");++ AwsException error = assertThrows(AwsException.class, () -> provisioner.provision(r, props, ctx()));++ assertEquals("ValidationError", error.getErrorCode());+ }++ @Test+ void groupUpdateSetsEnabledMetricsToExactlyWhatTheTemplateLists() {+ when(autoScaling.describeAutoScalingGroups(REGION, List.of("my-asg")))+ .thenReturn(List.of(group("my-asg")));+ StackResource r = resource(GROUP, "Asg", "my-asg");+ ObjectNode props = mapper.createObjectNode().put("AutoScalingGroupName", "my-asg");+ props.putArray("MetricsCollection").addObject().put("Granularity", "1Minute")+ .putArray("Metrics").add("GroupTotalInstances");++ provisioner.provision(r, props, ctx("my-asg"));++ verify(autoScaling).disableMetricsCollection(REGION, "my-asg", List.of());+ verify(autoScaling).enableMetricsCollection(REGION, "my-asg", List.of("GroupTotalInstances"), "1Minute");+ }+@Testvoid groupUpdateReconcilesTheSameNameInsteadOfCreatingItAgain() {// provision() re-runs on every UpdateStack. createAutoScalingGroup throws AlreadyExists, so@@ -325,11 +455,77 @@ class AutoScalingGroupCfnProvisionerTest {assertEquals(0, optionalFields.maxInstanceLifetime());assertEquals(AsgOptionalFields.DEFAULT_INSTANCE_WARMUP_REMOVAL_SENTINEL,optionalFields.defaultInstanceWarmup());+ // The group had no maintenance policy before the update, so rollback clears whatever the+ // update set, and restores the empty set of enabled metrics.+ assertEquals(InstanceMaintenancePolicy.REMOVAL_SENTINEL,+ optionalFields.instanceMaintenancePolicy().getMinHealthyPercentage());+ assertEquals(InstanceMaintenancePolicy.REMOVAL_SENTINEL,+ optionalFields.instanceMaintenancePolicy().getMaxHealthyPercentage());+ verify(autoScaling).disableMetricsCollection(REGION, "my-asg", List.of());// Subsequent rollback should return false since snapshot is spentassertFalse(provisioner.rollbackUpdate(r));}+ @Test+ void rollbackUpdateClearsMembersTheGroupDidNotHaveBeforeTheUpdate() {+ // UpdateAutoScalingGroup has no clearing value for these three, so passing the snapshot's+ // null through it would leave what the failed update added.+ AutoScalingGroup existing = group("my-asg");+ existing.setMinSize(1);+ existing.setMaxSize(5);+ when(autoScaling.describeAutoScalingGroups(eq(REGION), eq(List.of("my-asg"))))+ .thenReturn(List.of(existing));+ StackResource r = resource(GROUP, "Asg", "my-asg");+ ObjectNode props = mapper.createObjectNode()+ .put("AutoScalingGroupName", "my-asg")+ .put("ServiceLinkedRoleARN", "role-arn");+ props.putObject("AvailabilityZoneDistribution").put("CapacityDistributionStrategy", "balanced-only");+ props.putObject("CapacityReservationSpecification").put("CapacityReservationPreference", "none");+ provisioner.provision(r, props, ctx("my-asg"));+ existing.setServiceLinkedRoleArn("role-arn");+ existing.setAvailabilityZoneDistribution(new AvailabilityZoneDistribution("balanced-only"));+ CapacityReservationSpecification reservation = new CapacityReservationSpecification();+ reservation.setCapacityReservationPreference("none");+ existing.setCapacityReservationSpecification(reservation);++ assertTrue(provisioner.rollbackUpdate(r));++ assertNull(existing.getServiceLinkedRoleArn());+ assertNull(existing.getAvailabilityZoneDistribution());+ assertNull(existing.getCapacityReservationSpecification());+ verify(autoScaling).saveAutoScalingGroupIfPresent(existing);+ }++ @Test+ void groupCreatePassesBlankRoleAndWeightToTheServiceForValidation() {+ // The service rejects an empty ServiceLinkedRoleARN or WeightedCapacity. Turning either+ // into null here would read as "not set" and let the stack through.+ when(autoScaling.createAutoScalingGroup(eq(REGION), eq("my-asg"), any(), any(), any(), any(),+ any(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(), anyList(),+ any(), anyInt(), anyList(), anyMap(), anyMap(), any()))+ .thenReturn(group("my-asg"));+ StackResource r = resource(GROUP, "Asg", null);+ ObjectNode props = mapper.createObjectNode()+ .put("AutoScalingGroupName", "my-asg")+ .put("ServiceLinkedRoleARN", "");+ ObjectNode launchTemplate = props.putObject("MixedInstancesPolicy").putObject("LaunchTemplate");+ launchTemplate.putObject("LaunchTemplateSpecification").put("LaunchTemplateId", "lt-123");+ launchTemplate.putArray("Overrides").addObject()+ .put("InstanceType", "t3.micro")+ .put("WeightedCapacity", "");++ provisioner.provision(r, props, ctx());++ ArgumentCaptor<MixedInstancesPolicy> policyCaptor = ArgumentCaptor.forClass(MixedInstancesPolicy.class);+ ArgumentCaptor<AsgOptionalFields> captor = ArgumentCaptor.forClass(AsgOptionalFields.class);+ verify(autoScaling).createAutoScalingGroup(eq(REGION), eq("my-asg"), any(), any(), any(), any(),+ policyCaptor.capture(), anyInt(), anyInt(), anyInt(), anyInt(), anyList(), anyList(), anyList(),+ anyList(), any(), anyInt(), anyList(), anyMap(), anyMap(), captor.capture());+ assertEquals("", captor.getValue().serviceLinkedRoleArn());+ assertEquals("", policyCaptor.getValue().getLaunchTemplate().getOverrides().getFirst().getWeightedCapacity());+ }+@Testvoid clearUpdateRemovesSnapshotAttribute() {StackResource r = resource(GROUP, "Asg", "my-asg");