Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ec2): Capacity Reservation CRUD (#2974)
lex000c33ef234bde
diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 00d9d833fe..64b281adc2 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -467,6 +467,26 @@ Route table ids follow the live API's own inconsistency: an id that does not exi| DescribeNatGateways | Lists or returns stored NAT gateways. || DeleteNatGateway | Deletes a NAT gateway record. |+### Capacity Reservations++| Action | Description |+|--------|-------------|+| CreateCapacityReservation | Reserves EC2 instance capacity in a specific Availability Zone. |+| DescribeCapacityReservations | Lists or returns stored Capacity Reservations. |+| ModifyCapacityReservation | Updates `InstanceCount`, `EndDate`, `EndDateType` or `InstanceMatchCriteria` in place. |+| CancelCapacityReservation | Marks a Capacity Reservation `cancelled` and its available count `0`, matching real AWS's retain-but-cancel behaviour rather than deleting the record. |++`InstanceType`, `InstancePlatform` and `InstanceCount` are required, matching the AWS API, and+one of `AvailabilityZone` or `AvailabilityZoneId` must be given; a request missing any of+these is rejected with `MissingParameter`. `InstanceCount` must be greater than `0` on create+and on modify, otherwise `InvalidParameterValue`. `InstanceMatchCriteria` defaults to `open`,+`Tenancy` defaults to `default` and `EndDateType` defaults to `unlimited`. Creation is+synchronous: the reservation comes back `active` on the create response rather than passing+through `payment-pending`/`assessing`. `DescribeCapacityReservations` supports the+`availability-zone`, `end-date-type`, `instance-match-criteria`, `instance-platform`,+`instance-type`, `state` and `tenancy` filters alongside the shared `tag:`, `tag-key` and+`tag-value` filters.+### Elastic IPs| Action | Description |diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex 599702879e..c772653a50 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@@ -165,6 +165,8 @@ public class AwsQueryController {"CreateNetworkAclEntry", "ReplaceNetworkAclEntry", "DeleteNetworkAclEntry","ReplaceNetworkAclAssociation","CreateNatGateway", "DescribeNatGateways", "DeleteNatGateway",+ "CreateCapacityReservation", "DescribeCapacityReservations",+ "ModifyCapacityReservation", "CancelCapacityReservation","AllocateAddress", "AssociateAddress", "DisassociateAddress", "ReleaseAddress", "DescribeAddresses","DescribeAddressesAttribute","DescribeIamInstanceProfileAssociations",diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.javaindex 1bdb2da1a4..4a7a99a788 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java@@ -209,6 +209,11 @@ public class Ec2QueryHandler {case "CreateNatGateway" -> handleCreateNatGateway(params, region);case "DescribeNatGateways" -> handleDescribeNatGateways(params, region);case "DeleteNatGateway" -> handleDeleteNatGateway(params, region);+ // Capacity Reservations+ case "CreateCapacityReservation" -> handleCreateCapacityReservation(params, region);+ case "DescribeCapacityReservations" -> handleDescribeCapacityReservations(params, region);+ case "ModifyCapacityReservation" -> handleModifyCapacityReservation(params, region);+ case "CancelCapacityReservation" -> handleCancelCapacityReservation(params, region);// Elastic IPscase "AllocateAddress" -> handleAllocateAddress(params, region);case "AssociateAddress" -> handleAssociateAddress(params, region);@@ -3213,6 +3218,105 @@ public class Ec2QueryHandler {return xmlResponse(xml.build());}+ // ─── Capacity Reservation handlers ────────────────────────────────────────++ private Response handleCreateCapacityReservation(MultivaluedMap<String, String> p, String region) {+ CapacityReservation reservation = service.createCapacityReservation(+ region,+ p.getFirst("InstanceType"),+ p.getFirst("InstancePlatform"),+ p.getFirst("AvailabilityZone"),+ p.getFirst("AvailabilityZoneId"),+ intOrNull(p, "InstanceCount"),+ p.getFirst("Tenancy"),+ p.getFirst("EbsOptimized") != null ? Boolean.valueOf(p.getFirst("EbsOptimized")) : null,+ p.getFirst("EphemeralStorage") != null ? Boolean.valueOf(p.getFirst("EphemeralStorage")) : null,+ p.getFirst("EndDateType"),+ instantOrNull(p, "EndDate"),+ p.getFirst("InstanceMatchCriteria"),+ p.getFirst("OutpostArn"),+ p.getFirst("PlacementGroupArn"));+ applyResourceTags(p, region, "capacity-reservation", reservation.getCapacityReservationId());+ XmlBuilder xml = new XmlBuilder()+ .start("CreateCapacityReservationResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("capacityReservation").raw(capacityReservationXml(reservation)).end("capacityReservation")+ .end("CreateCapacityReservationResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeCapacityReservations(MultivaluedMap<String, String> p, String region) {+ List<String> ids = getList(p, "CapacityReservationId");+ Map<String, List<String>> filters = getFilters(p);+ List<CapacityReservation> reservations = service.describeCapacityReservations(region, ids, filters);+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeCapacityReservationsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("capacityReservationSet");+ for (CapacityReservation reservation : reservations) {+ xml.start("item").raw(capacityReservationXml(reservation)).end("item");+ }+ xml.end("capacityReservationSet").end("DescribeCapacityReservationsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleModifyCapacityReservation(MultivaluedMap<String, String> p, String region) {+ service.modifyCapacityReservation(+ region,+ p.getFirst("CapacityReservationId"),+ intOrNull(p, "InstanceCount"),+ instantOrNull(p, "EndDate"),+ p.getFirst("EndDateType"),+ p.getFirst("InstanceMatchCriteria"));+ return booleanResponse("ModifyCapacityReservation");+ }++ private Response handleCancelCapacityReservation(MultivaluedMap<String, String> p, String region) {+ service.cancelCapacityReservation(region, p.getFirst("CapacityReservationId"));+ return booleanResponse("CancelCapacityReservation");+ }++ private String capacityReservationXml(CapacityReservation reservation) {+ XmlBuilder xml = new XmlBuilder()+ .elem("capacityReservationId", reservation.getCapacityReservationId())+ .elem("ownerId", reservation.getOwnerId())+ .elem("capacityReservationArn", reservation.getCapacityReservationArn())+ .elem("availabilityZoneId", reservation.getAvailabilityZoneId())+ .elem("availabilityZone", reservation.getAvailabilityZone())+ .elem("instanceType", reservation.getInstanceType())+ .elem("instancePlatform", reservation.getInstancePlatform())+ .elem("tenancy", reservation.getTenancy())+ .elem("totalInstanceCount", reservation.getTotalInstanceCount())+ .elem("availableInstanceCount", reservation.getAvailableInstanceCount())+ .elem("ebsOptimized", reservation.isEbsOptimized())+ .elem("ephemeralStorage", reservation.isEphemeralStorage())+ .elem("state", reservation.getState())+ .elem("startDate", reservation.getStartDate() != null ? ISO_FMT.format(reservation.getStartDate()) : null)+ .elem("endDate", reservation.getEndDate() != null ? ISO_FMT.format(reservation.getEndDate()) : null)+ .elem("endDateType", reservation.getEndDateType())+ .elem("instanceMatchCriteria", reservation.getInstanceMatchCriteria())+ .elem("createDate", reservation.getCreateDate() != null ? ISO_FMT.format(reservation.getCreateDate()) : null)+ .elem("outpostArn", reservation.getOutpostArn())+ .elem("placementGroupArn", reservation.getPlacementGroupArn())+ .raw(tagSetXml(reservation.getTags()));+ return xml.build();+ }++ // Unlike intOrNull's silent skip of absent values, a present but unparseable timestamp is a+ // caller mistake and is rejected rather than coerced to null.+ private java.time.Instant instantOrNull(MultivaluedMap<String, String> p, String name) {+ String value = p.getFirst(name);+ if (value == null || value.isBlank()) {+ return null;+ }+ try {+ return java.time.Instant.parse(value);+ } catch (java.time.format.DateTimeParseException e) {+ throw new AwsException("InvalidParameterValue",+ "The specified value for " + name + " is not valid.", 400);+ }+ }+// ─── Elastic IP handlers ──────────────────────────────────────────────────private Response handleAllocateAddress(MultivaluedMap<String, String> p, String region) {diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex ed075edf62..fad1c44d33 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -43,6 +43,7 @@ import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.ec2.model.Address;import io.github.hectorvent.floci.services.ec2.model.BlockDeviceMapping;+import io.github.hectorvent.floci.services.ec2.model.CapacityReservation;import io.github.hectorvent.floci.services.ec2.model.EbsBlockDevice;import io.github.hectorvent.floci.services.ec2.model.GroupIdentifier;import io.github.hectorvent.floci.services.ec2.portforward.Ec2PortForwardManager;@@ -179,6 +180,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {private final StorageBackend<String, NetworkInterface> networkInterfaces;// resourceId → List<Tag>private final StorageBackend<String, List<Tag>> tags;+ private final StorageBackend<String, CapacityReservation> capacityReservations;private final Set<String> seededRegions = ConcurrentHashMap.newKeySet();// subnetId → counter for IP assignment (runtime-only, not persisted)private final Map<String, AtomicInteger> subnetIpCounters = new ConcurrentHashMap<>();@@ -232,6 +234,8 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {new TypeReference<Map<String, VpcPeeringConnection>>() {}),storageFactory.create("ec2", "ec2-network-interfaces.json",new TypeReference<Map<String, NetworkInterface>>() {}),+ storageFactory.create("ec2", "ec2-capacity-reservations.json",+ new TypeReference<Map<String, CapacityReservation>>() {}),requestContextInstance);}@@ -265,7 +269,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {natGateways, spotInstanceRequests, networkAcls, managedPrefixLists, tags,new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),- new InMemoryStorage<>(), null);+ new InMemoryStorage<>(), new InMemoryStorage<>(), null);}// Package-private for hermetic tests, transit-gateway-aware. The shorter overload above keeps its@@ -305,7 +309,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {natGateways, spotInstanceRequests, networkAcls, managedPrefixLists, tags,transitGateways, transitGatewayRouteTables, transitGatewayVpcAttachments,transitGatewayPropagations, transitGatewayRoutes, vpcPeeringConnections,- new InMemoryStorage<>(), null);+ new InMemoryStorage<>(), new InMemoryStorage<>(), null);}// Package-private for hermetic tests that also need to control which account a caller resolves@@ -340,6 +344,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes,StorageBackend<String, VpcPeeringConnection> vpcPeeringConnections,StorageBackend<String, NetworkInterface> networkInterfaces,+ StorageBackend<String, CapacityReservation> capacityReservations,jakarta.enterprise.inject.Instance<RequestContext> requestContextInstance) {this.accountId = config.defaultAccountId();this.requestContextInstance = requestContextInstance;@@ -375,6 +380,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {this.transitGatewayRoutes = transitGatewayRoutes;this.vpcPeeringConnections = vpcPeeringConnections;this.networkInterfaces = networkInterfaces;+ this.capacityReservations = capacityReservations;}@PostConstruct@@ -4578,6 +4584,8 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {if (inst != null) { inst.setTags(new ArrayList<>(tagList)); instances.put(storeKey, inst); return; }Vpc vpc = vpcs.get(storeKey).orElse(null);if (vpc != null) { vpc.setTags(new ArrayList<>(tagList)); vpcs.put(storeKey, vpc); return; }+ CapacityReservation cr = capacityReservations.get(storeKey).orElse(null);+ if (cr != null) { cr.setTags(new ArrayList<>(tagList)); capacityReservations.put(storeKey, cr); return; }Subnet subnet = subnets.get(storeKey).orElse(null);if (subnet != null) { subnet.setTags(new ArrayList<>(tagList)); subnets.put(storeKey, subnet); return; }SecurityGroup sg = securityGroups.get(storeKey).orElse(null);@@ -4668,6 +4676,9 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {if (resourceId.startsWith("i-")) {return "instance";}+ if (resourceId.startsWith("cr-")) {+ return "capacity-reservation";+ }if (resourceId.startsWith("vpc-")) {return "vpc";}@@ -4774,6 +4785,140 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {return igw;}+ // ─── Capacity Reservations ─────────────────────────────────────────────────++ /**+ * Creates a Capacity Reservation, {@code active} on the create response and on the first+ * describe. Real AWS passes through {@code payment-pending}/{@code assessing} first;+ * nothing about creating one is slow here, so the terminal state is reported immediately,+ * the same synchronous-create simplification the other regional EC2 resources make.+ */+ public CapacityReservation createCapacityReservation(String region, String instanceType,+ String instancePlatform, String availabilityZone, String availabilityZoneId, Integer instanceCount,+ String tenancy, Boolean ebsOptimized, Boolean ephemeralStorage, String endDateType,+ java.time.Instant endDate, String instanceMatchCriteria, String outpostArn, String placementGroupArn) {+ ensureDefaultResources(region);+ if (instanceType == null || instanceType.isBlank()) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter InstanceType.", 400);+ }+ if (instancePlatform == null || instancePlatform.isBlank()) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter InstancePlatform.", 400);+ }+ if (instanceCount == null) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter InstanceCount.", 400);+ }+ if ((availabilityZone == null || availabilityZone.isBlank())+ && (availabilityZoneId == null || availabilityZoneId.isBlank())) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter AvailabilityZone or AvailabilityZoneId.", 400);+ }+ int count = requirePositiveInstanceCount(instanceCount);+ CapacityReservation reservation = new CapacityReservation();+ reservation.setCapacityReservationId("cr-" + randomHex(17));+ reservation.setOwnerId(accountId);+ reservation.setRegion(region);+ reservation.setCapacityReservationArn(+ AwsArnUtils.Arn.of("ec2", region, accountId, "capacity-reservation/" + reservation.getCapacityReservationId()).toString());+ reservation.setAvailabilityZone(availabilityZone);+ reservation.setAvailabilityZoneId(availabilityZoneId);+ reservation.setInstanceType(instanceType);+ reservation.setInstancePlatform(instancePlatform);+ reservation.setTenancy(tenancy != null ? tenancy : "default");+ reservation.setTotalInstanceCount(count);+ reservation.setAvailableInstanceCount(count);+ reservation.setEbsOptimized(Boolean.TRUE.equals(ebsOptimized));+ reservation.setEphemeralStorage(Boolean.TRUE.equals(ephemeralStorage));+ reservation.setState("active");+ reservation.setStartDate(Instant.now());+ reservation.setCreateDate(Instant.now());+ reservation.setEndDate(endDate);+ reservation.setEndDateType(endDateType != null ? endDateType : "unlimited");+ reservation.setInstanceMatchCriteria(instanceMatchCriteria != null ? instanceMatchCriteria : "open");+ reservation.setOutpostArn(outpostArn);+ reservation.setPlacementGroupArn(placementGroupArn);+ capacityReservations.put(key(region, reservation.getCapacityReservationId()), reservation);+ return reservation;+ }++ public List<CapacityReservation> describeCapacityReservations(String region, List<String> ids,+ Map<String, List<String>> filters) {+ ensureDefaultResources(region);+ for (String id : ids) {+ getRequiredCapacityReservation(region, id);+ }+ return capacityReservations.scan(k -> true).stream()+ .filter(r -> r.getRegion().equals(region))+ .filter(r -> ids.isEmpty() || ids.contains(r.getCapacityReservationId()))+ .filter(r -> matchesFilters(r, filters, region))+ .collect(Collectors.toList());+ }++ /**+ * Applies an in-place update. AWS forbids changing instance type, EBS optimization,+ * platform, instance store, Availability Zone or tenancy after creation, and the caller+ * (the AWS provider's own update path) never asks for that, so nothing here re-checks it.+ */+ public CapacityReservation modifyCapacityReservation(String region, String capacityReservationId,+ Integer instanceCount, java.time.Instant endDate, String endDateType, String instanceMatchCriteria) {+ ensureDefaultResources(region);+ CapacityReservation reservation = getRequiredCapacityReservation(region, capacityReservationId);+ if (instanceCount != null) {+ int delta = requirePositiveInstanceCount(instanceCount) - reservation.getTotalInstanceCount();+ reservation.setTotalInstanceCount(instanceCount);+ reservation.setAvailableInstanceCount(Math.max(0, reservation.getAvailableInstanceCount() + delta));+ }+ if (endDateType != null) {+ reservation.setEndDateType(endDateType);+ }+ // AWS clears EndDate when EndDateType moves back to "unlimited"; ModifyCapacityReservation+ // has no way to explicitly clear EndDate otherwise (CancelCapacityReservation is the only+ // other transition), so mirror that here rather than leaving a stale date behind.+ if ("unlimited".equals(reservation.getEndDateType())) {+ reservation.setEndDate(null);+ } else if (endDate != null) {+ reservation.setEndDate(endDate);+ }+ if (instanceMatchCriteria != null) {+ reservation.setInstanceMatchCriteria(instanceMatchCriteria);+ }+ capacityReservations.put(key(region, capacityReservationId), reservation);+ return reservation;+ }++ /**+ * Marks the reservation cancelled with zero available capacity rather than deleting the+ * record, matching AWS's retain-but-cancel behaviour: a cancelled reservation still+ * appears in DescribeCapacityReservations.+ */+ public void cancelCapacityReservation(String region, String capacityReservationId) {+ ensureDefaultResources(region);+ CapacityReservation reservation = getRequiredCapacityReservation(region, capacityReservationId);+ reservation.setState("cancelled");+ reservation.setAvailableInstanceCount(0);+ capacityReservations.put(key(region, capacityReservationId), reservation);+ }++ private int requirePositiveInstanceCount(int instanceCount) {+ if (instanceCount <= 0) {+ throw new AwsException("InvalidParameterValue",+ "Value (" + instanceCount + ") for parameter InstanceCount is invalid. "+ + "InstanceCount must be greater than 0.", 400);+ }+ return instanceCount;+ }++ private CapacityReservation getRequiredCapacityReservation(String region, String capacityReservationId) {+ CapacityReservation reservation = capacityReservations.get(key(region, capacityReservationId)).orElse(null);+ if (reservation == null) {+ throw new AwsException("InvalidCapacityReservationId.NotFound",+ "The Capacity Reservation '" + capacityReservationId + "' does not exist.", 400);+ }+ return reservation;+ }+// ─── Route Tables ──────────────────────────────────────────────────────────public RouteTable createRouteTable(String region, String vpcId) {@@ -6011,6 +6156,18 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {default -> true;};}+ if (resource instanceof CapacityReservation cr) {+ return switch (filterName) {+ case "instance-type" -> matchesValue(values, cr.getInstanceType());+ case "availability-zone" -> matchesValue(values, cr.getAvailabilityZone());+ case "tenancy" -> matchesValue(values, cr.getTenancy());+ case "state" -> matchesValue(values, cr.getState());+ case "instance-platform" -> matchesValue(values, cr.getInstancePlatform());+ case "instance-match-criteria" -> matchesValue(values, cr.getInstanceMatchCriteria());+ case "end-date-type" -> matchesValue(values, cr.getEndDateType());+ default -> true;+ };+ }return true;}@@ -6034,6 +6191,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {if (resource instanceof TransitGatewayRouteTable routeTable) return routeTable.getTags();if (resource instanceof TransitGatewayVpcAttachment attachment) return attachment.getTags();if (resource instanceof VpcPeeringConnection pcx) return pcx.getTags();+ if (resource instanceof CapacityReservation cr) return cr.getTags();return Collections.emptyList();}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/CapacityReservation.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/CapacityReservation.javanew file mode 100644index 0000000000..36f1a263bf--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/CapacityReservation.java@@ -0,0 +1,113 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.List;++/**+ * A reservation of EC2 instance capacity in a specific Availability Zone, created ahead of+ * time so a later {@code RunInstances} (or an Auto Scaling warm pool / launch template) is+ * guaranteed the capacity it targets.+ *+ * <p>Real AWS transitions a Capacity Reservation through {@code payment-pending}/+ * {@code assessing} before {@code active}; nothing about creating one is slow here, so it is+ * {@code active} on the create response and on the first describe, the same synchronous-create+ * simplification the other regional EC2 resources make.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class CapacityReservation {++ private String capacityReservationId;+ private String ownerId;+ private String capacityReservationArn;+ private String availabilityZone;+ private String availabilityZoneId;+ private String instanceType;+ private String instancePlatform;+ private String tenancy = "default";+ private int totalInstanceCount;+ private int availableInstanceCount;+ private boolean ebsOptimized;+ private boolean ephemeralStorage;+ private String state = "active";+ private Instant startDate;+ private Instant endDate;+ private String endDateType = "unlimited";+ private String instanceMatchCriteria = "open";+ private Instant createDate;+ private String outpostArn;+ private String placementGroupArn;+ private String region;+ private List<Tag> tags = new ArrayList<>();++ public CapacityReservation() {}++ public String getCapacityReservationId() { return capacityReservationId; }+ public void setCapacityReservationId(String capacityReservationId) { this.capacityReservationId = capacityReservationId; }++ public String getOwnerId() { return ownerId; }+ public void setOwnerId(String ownerId) { this.ownerId = ownerId; }++ public String getCapacityReservationArn() { return capacityReservationArn; }+ public void setCapacityReservationArn(String capacityReservationArn) { this.capacityReservationArn = capacityReservationArn; }++ public String getAvailabilityZone() { return availabilityZone; }+ public void setAvailabilityZone(String availabilityZone) { this.availabilityZone = availabilityZone; }+ public String getAvailabilityZoneId() { return availabilityZoneId; }+ public void setAvailabilityZoneId(String availabilityZoneId) { this.availabilityZoneId = availabilityZoneId; }++ public String getInstanceType() { return instanceType; }+ public void setInstanceType(String instanceType) { this.instanceType = instanceType; }++ public String getInstancePlatform() { return instancePlatform; }+ public void setInstancePlatform(String instancePlatform) { this.instancePlatform = instancePlatform; }++ public String getTenancy() { return tenancy; }+ public void setTenancy(String tenancy) { this.tenancy = tenancy; }++ public int getTotalInstanceCount() { return totalInstanceCount; }+ public void setTotalInstanceCount(int totalInstanceCount) { this.totalInstanceCount = totalInstanceCount; }++ public int getAvailableInstanceCount() { return availableInstanceCount; }+ public void setAvailableInstanceCount(int availableInstanceCount) { this.availableInstanceCount = availableInstanceCount; }++ public boolean isEbsOptimized() { return ebsOptimized; }+ public void setEbsOptimized(boolean ebsOptimized) { this.ebsOptimized = ebsOptimized; }++ public boolean isEphemeralStorage() { return ephemeralStorage; }+ public void setEphemeralStorage(boolean ephemeralStorage) { this.ephemeralStorage = ephemeralStorage; }++ public String getState() { return state; }+ public void setState(String state) { this.state = state; }++ public Instant getStartDate() { return startDate; }+ public void setStartDate(Instant startDate) { this.startDate = startDate; }++ public Instant getEndDate() { return endDate; }+ public void setEndDate(Instant endDate) { this.endDate = endDate; }++ public String getEndDateType() { return endDateType; }+ public void setEndDateType(String endDateType) { this.endDateType = endDateType; }++ public String getInstanceMatchCriteria() { return instanceMatchCriteria; }+ public void setInstanceMatchCriteria(String instanceMatchCriteria) { this.instanceMatchCriteria = instanceMatchCriteria; }++ public Instant getCreateDate() { return createDate; }+ public void setCreateDate(Instant createDate) { this.createDate = createDate; }++ public String getOutpostArn() { return outpostArn; }+ public void setOutpostArn(String outpostArn) { this.outpostArn = outpostArn; }++ public String getPlacementGroupArn() { return placementGroupArn; }+ public void setPlacementGroupArn(String placementGroupArn) { this.placementGroupArn = placementGroupArn; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public List<Tag> getTags() { return tags; }+ public void setTags(List<Tag> tags) { this.tags = tags; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CapacityReservationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CapacityReservationIntegrationTest.javanew file mode 100644index 0000000000..699100ca6b--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CapacityReservationIntegrationTest.java@@ -0,0 +1,356 @@+package io.github.hectorvent.floci.services.ec2;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Integration tests for EC2 Capacity Reservations over the Query protocol: create with inline+ * tags, describe by id and by filter, modify in place, tag round trip through CreateTags, and+ * cancel (lex00/floci#64 - previously entirely unimplemented, blocking+ * terraform-aws-modules/terraform-aws-autoscaling's flagship "complete" example, which declares+ * an {@code aws_ec2_capacity_reservation} targeted by a warm pool).+ *+ * <p>Ordered because the cases walk one reservation through its lifecycle.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class Ec2CapacityReservationIntegrationTest {++ private static final String AUTH_HEADER =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/ec2/aws4_request";++ private static String capacityReservationId;++ @Test+ @Order(1)+ void createReturnsActiveOnTheFirstRead() {+ capacityReservationId = given()+ .formParam("Action", "CreateCapacityReservation")+ .formParam("InstanceType", "t3.micro")+ .formParam("InstancePlatform", "Linux/UNIX")+ .formParam("AvailabilityZone", "us-east-1a")+ .formParam("InstanceCount", "3")+ .formParam("InstanceMatchCriteria", "targeted")+ .formParam("TagSpecification.1.ResourceType", "capacity-reservation")+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", "warm-pool-reservation")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateCapacityReservationResponse.capacityReservation.state", equalTo("active"))+ .body("CreateCapacityReservationResponse.capacityReservation.instanceType", equalTo("t3.micro"))+ .body("CreateCapacityReservationResponse.capacityReservation.instancePlatform", equalTo("Linux/UNIX"))+ .body("CreateCapacityReservationResponse.capacityReservation.availabilityZone", equalTo("us-east-1a"))+ .body("CreateCapacityReservationResponse.capacityReservation.totalInstanceCount", equalTo("3"))+ .body("CreateCapacityReservationResponse.capacityReservation.availableInstanceCount", equalTo("3"))+ .body("CreateCapacityReservationResponse.capacityReservation.instanceMatchCriteria", equalTo("targeted"))+ .body("CreateCapacityReservationResponse.capacityReservation.tenancy", equalTo("default"))+ .body("CreateCapacityReservationResponse.capacityReservation.endDateType", equalTo("unlimited"))+ .body("CreateCapacityReservationResponse.capacityReservation.capacityReservationArn",+ containsString(":capacity-reservation/cr-"))+ .body("CreateCapacityReservationResponse.capacityReservation.tagSet.item.key", equalTo("Name"))+ .body("CreateCapacityReservationResponse.capacityReservation.tagSet.item.value", equalTo("warm-pool-reservation"))+ .extract().path("CreateCapacityReservationResponse.capacityReservation.capacityReservationId");++ assertTrue(capacityReservationId.startsWith("cr-"), "id must use the cr- prefix");+ }++ @Test+ @Order(2)+ void describeByIdReturnsTheCreatedReservationStillActive() {+ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("CapacityReservationId.1", capacityReservationId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.capacityReservationId",+ equalTo(capacityReservationId))+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.state", equalTo("active"));+ }++ @Test+ @Order(3)+ void describeSupportsInstanceTypeAndTagFilters() {+ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("Filter.1.Name", "instance-type")+ .formParam("Filter.1.Value.1", "t3.micro")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.capacityReservationId",+ equalTo(capacityReservationId));++ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("Filter.1.Name", "tag:Name")+ .formParam("Filter.1.Value.1", "warm-pool-reservation")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.capacityReservationId",+ equalTo(capacityReservationId));+ }++ @Test+ @Order(4)+ void createTagsIsVisibleOnTheNextDescribe() {+ given()+ .formParam("Action", "CreateTags")+ .formParam("ResourceId.1", capacityReservationId)+ .formParam("Tag.1.Key", "env")+ .formParam("Tag.1.Value", "staging")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("Filter.1.Name", "tag:env")+ .formParam("Filter.1.Value.1", "staging")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.capacityReservationId",+ equalTo(capacityReservationId));+ }++ @Test+ @Order(5)+ void modifyChangesInstanceCountAndAvailableCountTogether() {+ given()+ .formParam("Action", "ModifyCapacityReservation")+ .formParam("CapacityReservationId", capacityReservationId)+ .formParam("InstanceCount", "5")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyCapacityReservationResponse.return", equalTo("true"));++ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("CapacityReservationId.1", capacityReservationId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.totalInstanceCount", equalTo("5"))+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.availableInstanceCount", equalTo("5"));+ }++ @Test+ @Order(6)+ void createWithoutInstanceCountIsRejected() {+ given()+ .formParam("Action", "CreateCapacityReservation")+ .formParam("InstanceType", "t3.nano")+ .formParam("InstancePlatform", "Linux/UNIX")+ .formParam("AvailabilityZone", "us-east-1b")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("MissingParameter"))+ .body("Response.Errors.Error.Message", containsString("InstanceCount"));+ }++ @Test+ @Order(7)+ void nonPositiveInstanceCountIsRejectedOnCreateAndModify() {+ given()+ .formParam("Action", "CreateCapacityReservation")+ .formParam("InstanceType", "t3.nano")+ .formParam("InstancePlatform", "Linux/UNIX")+ .formParam("AvailabilityZone", "us-east-1b")+ .formParam("InstanceCount", "0")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"));++ given()+ .formParam("Action", "ModifyCapacityReservation")+ .formParam("CapacityReservationId", capacityReservationId)+ .formParam("InstanceCount", "-1")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"));++ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("CapacityReservationId.1", capacityReservationId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.totalInstanceCount", equalTo("5"))+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.availableInstanceCount", equalTo("5"));+ }++ @Test+ @Order(8)+ void createAcceptsAvailabilityZoneIdInsteadOfAvailabilityZone() {+ given()+ .formParam("Action", "CreateCapacityReservation")+ .formParam("InstanceType", "t3.nano")+ .formParam("InstancePlatform", "Linux/UNIX")+ .formParam("AvailabilityZoneId", "use1-az2")+ .formParam("InstanceCount", "1")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateCapacityReservationResponse.capacityReservation.availabilityZoneId", equalTo("use1-az2"))+ .body("CreateCapacityReservationResponse.capacityReservation.totalInstanceCount", equalTo("1"))+ .body("CreateCapacityReservationResponse.capacityReservation.instanceMatchCriteria", equalTo("open"));++ given()+ .formParam("Action", "CreateCapacityReservation")+ .formParam("InstanceType", "t3.nano")+ .formParam("InstancePlatform", "Linux/UNIX")+ .formParam("InstanceCount", "1")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("MissingParameter"));+ }++ @Test+ @Order(9)+ void missingRequiredParameterIsRejected() {+ given()+ .formParam("Action", "CreateCapacityReservation")+ .formParam("AvailabilityZone", "us-east-1a")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("MissingParameter"));+ }++ @Test+ @Order(10)+ void cancelMarksTheReservationCancelledRatherThanDeletingIt() {+ given()+ .formParam("Action", "CancelCapacityReservation")+ .formParam("CapacityReservationId", capacityReservationId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CancelCapacityReservationResponse.return", equalTo("true"));++ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("CapacityReservationId.1", capacityReservationId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.state", equalTo("cancelled"))+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.availableInstanceCount", equalTo("0"));+ }++ @Test+ @Order(11)+ void describingAMissingReservationReturnsTheModelledError() {+ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("CapacityReservationId.1", "cr-00000000000000000")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidCapacityReservationId.NotFound"))+ .body("Response.Errors.Error.Message", containsString("cr-00000000000000000"));+ }++ /**+ * {@code parseTagsForResource} accepts both TagSpecification spellings for every action.+ * Order(1) covers the singular form. This test covers the plural form and reads the tags+ * back through Describe.+ */+ @Test+ @Order(12)+ void createHonoursThePluralTagSpecificationsParameter() {+ String id = given()+ .formParam("Action", "CreateCapacityReservation")+ .formParam("InstanceType", "t3.micro")+ .formParam("InstancePlatform", "Linux/UNIX")+ .formParam("AvailabilityZone", "us-east-1a")+ .formParam("InstanceCount", "1")+ .formParam("InstanceMatchCriteria", "targeted")+ .formParam("TagSpecifications.1.ResourceType", "capacity-reservation")+ .formParam("TagSpecifications.1.Tag.1.Key", "Name")+ .formParam("TagSpecifications.1.Tag.1.Value", "plural-form-reservation")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateCapacityReservationResponse.capacityReservation.tagSet.item.key", equalTo("Name"))+ .body("CreateCapacityReservationResponse.capacityReservation.tagSet.item.value", equalTo("plural-form-reservation"))+ .extract().path("CreateCapacityReservationResponse.capacityReservation.capacityReservationId");++ given()+ .formParam("Action", "DescribeCapacityReservations")+ .formParam("CapacityReservationId.1", id)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.tagSet.item.key", equalTo("Name"))+ .body("DescribeCapacityReservationsResponse.capacityReservationSet.item.tagSet.item.value", equalTo("plural-form-reservation"));++ given()+ .formParam("Action", "DescribeTags")+ .formParam("Filter.1.Name", "resource-id")+ .formParam("Filter.1.Value.1", id)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeTagsResponse.tagSet.item.key", equalTo("Name"))+ .body("DescribeTagsResponse.tagSet.item.value", equalTo("plural-form-reservation"));+ }+}