Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
index 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.md
index 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 and
dropped.
+`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 effect
by the request carries at least one launch template override with `InstanceRequirements`. On create
that 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 Compatibility
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.md
index 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 Updates
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java
index 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.java
index 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);
// Instances
case "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.java
index 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.java
index 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.java
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.java
index 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.java
index 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.java
new file mode 100644
index 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.java
index 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.java
index 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>"));
}
@Test
diff --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.java
index 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");
+ }
+
@Test
void 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 spent
assertFalse(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());
+ }
+
@Test
void clearUpdateRemovesSnapshotAttribute() {
StackResource r = resource(GROUP, "Asg", "my-asg");