Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ec2): support Dedicated Hosts (AllocateHosts, DescribeHosts, ModifyHosts, ReleaseHosts) (#4816)
Allen Sanborna4c952db5448
diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex c797481169..8e8cb2ef12 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -542,6 +542,24 @@ through `payment-pending`/`assessing`. `DescribeCapacityReservations` supports t`instance-type`, `state` and `tenancy` filters alongside the shared `tag:`, `tag-key` and`tag-value` filters.+### Dedicated Hosts++| Action | Description |+|--------|-------------|+| AllocateHosts | Allocates `Quantity` (default `1`) Dedicated Hosts, `available` immediately, with `dedicated-host` tags from `TagSpecification`. |+| DescribeHosts | Lists or returns stored hosts, including the instances placed on each. |+| ModifyHosts | Updates `AutoPlacement`, `HostRecovery`, `HostMaintenance`, `InstanceType` or `InstanceFamily`. |+| ReleaseHosts | Marks hosts `released`; they stay visible in `DescribeHosts`, as on AWS. |++`AvailabilityZone` and exactly one of `InstanceType` or `InstanceFamily` are required.+`AutoPlacement` and `HostRecovery` default to `off` and `HostMaintenance` to `on`.+`DescribeHosts` with an unknown id fails with `InvalidHostID.NotFound`. `ModifyHosts` and+`ReleaseHosts` report each host separately: an unknown or already released host, or a host+still carrying instances on release, goes to `unsuccessful` instead of failing the call.+`RunInstances` accepts `Placement.HostId` and `Placement.Tenancy`; naming a host defaults the+tenancy to `host` and, without a subnet, the zone to the host's. `hostProperties` reports a+fixed socket/core/vCPU shape rather than one derived from the instance family.+### Elastic IPs| Action | Description |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 66b199cdf0..60765f7c88 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@@ -21,6 +21,7 @@ import java.time.Instant;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;import java.util.*;+import java.util.function.Consumer;@ApplicationScopedpublic class Ec2QueryHandler {@@ -237,6 +238,11 @@ public class Ec2QueryHandler {case "DescribeCapacityReservations" -> handleDescribeCapacityReservations(params, region);case "ModifyCapacityReservation" -> handleModifyCapacityReservation(params, region);case "CancelCapacityReservation" -> handleCancelCapacityReservation(params, region);+ // Dedicated Hosts+ case "AllocateHosts" -> handleAllocateHosts(params, region);+ case "DescribeHosts" -> handleDescribeHosts(params, region);+ case "ModifyHosts" -> handleModifyHosts(params, region);+ case "ReleaseHosts" -> handleReleaseHosts(params, region);// Elastic IPscase "AllocateAddress" -> handleAllocateAddress(params, region);case "AssociateAddress" -> handleAssociateAddress(params, region);@@ -793,7 +799,8 @@ public class Ec2QueryHandler {Reservation res = service.runInstances(region, imageId, instanceType, minCount, maxCount,keyName, sgIds, subnetId, clientToken, instanceTags, userData, iamInstanceProfileArn,associatePublicIp, networkInterfaceId, networkInterfaceDeviceIndex, null, metadataOptions,- creditSpecificationCpuCredits, userDataEncoded, Boolean.parseBoolean(p.getFirst("DryRun")));+ creditSpecificationCpuCredits, userDataEncoded, Boolean.parseBoolean(p.getFirst("DryRun")),+ p.getFirst("Placement.HostId"), p.getFirst("Placement.Tenancy"));if (!networkInterfaceTags.isEmpty()) {List<String> eniIds = new ArrayList<>();@@ -4056,6 +4063,125 @@ public class Ec2QueryHandler {return xml.build();}+ // ─── Dedicated Host handlers ──────────────────────────────────────────────++ private Response handleAllocateHosts(MultivaluedMap<String, String> p, String region) {+ List<String> assetIds = getList(p, "AssetId");+ List<Host> allocated = service.allocateHosts(+ region,+ p.getFirst("AvailabilityZone"),+ p.getFirst("InstanceType"),+ p.getFirst("InstanceFamily"),+ intOrNull(p, "Quantity"),+ p.getFirst("AutoPlacement"),+ p.getFirst("HostRecovery"),+ p.getFirst("HostMaintenance"),+ p.getFirst("OutpostArn"),+ assetIds.isEmpty() ? null : assetIds.get(0));+ XmlBuilder xml = new XmlBuilder()+ .start("AllocateHostsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("hostIdSet");+ for (Host host : allocated) {+ applyResourceTags(p, region, "dedicated-host", host.getHostId());+ xml.elem("item", host.getHostId());+ }+ xml.end("hostIdSet").end("AllocateHostsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeHosts(MultivaluedMap<String, String> p, String region) {+ List<Host> found = service.describeHosts(region, getList(p, "HostId"), getFilters(p));+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeHostsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("hostSet");+ for (Host host : found) {+ xml.start("item").raw(hostXml(region, host)).end("item");+ }+ xml.end("hostSet").end("DescribeHostsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleModifyHosts(MultivaluedMap<String, String> p, String region) {+ // Invalid values fail the whole call rather than landing in each host's unsuccessful item.+ service.validateHostSettings(p.getFirst("AutoPlacement"), p.getFirst("HostRecovery"),+ p.getFirst("HostMaintenance"));+ return hostBatchResponse("ModifyHosts", getList(p, "HostId"), id -> service.modifyHost(region, id,+ p.getFirst("AutoPlacement"), p.getFirst("HostRecovery"), p.getFirst("HostMaintenance"),+ p.getFirst("InstanceType"), p.getFirst("InstanceFamily")));+ }++ private Response handleReleaseHosts(MultivaluedMap<String, String> p, String region) {+ return hostBatchResponse("ReleaseHosts", getList(p, "HostId"), id -> service.releaseHost(region, id));+ }++ // ModifyHosts and ReleaseHosts answer per host: a host that cannot be changed goes to+ // unsuccessful with a Client.-prefixed code instead of failing the whole call.+ private Response hostBatchResponse(String action, List<String> hostIds,+ Consumer<String> perHost) {+ if (hostIds.isEmpty()) {+ throw new AwsException("MissingParameter", "The request must contain the parameter HostId.", 400);+ }+ XmlBuilder successful = new XmlBuilder();+ XmlBuilder unsuccessful = new XmlBuilder();+ for (String id : hostIds) {+ try {+ perHost.accept(id);+ successful.elem("item", id);+ } catch (AwsException e) {+ unsuccessful.start("item")+ .start("error")+ .elem("code", "Client." + e.getErrorCode())+ .elem("message", e.getMessage())+ .end("error")+ .elem("resourceId", id)+ .end("item");+ }+ }+ XmlBuilder xml = new XmlBuilder()+ .start(action + "Response", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("successful").raw(successful.build()).end("successful")+ .start("unsuccessful").raw(unsuccessful.build()).end("unsuccessful")+ .end(action + "Response");+ return xmlResponse(xml.build());+ }++ // ponytail: hostProperties cores/sockets/totalVCpus are a fixed m5-sized host shape; derive+ // per family from the instance type catalog if a caller ever asserts on them.+ private String hostXml(String region, Host host) {+ XmlBuilder xml = new XmlBuilder()+ .elem("hostId", host.getHostId())+ .elem("ownerId", host.getOwnerId())+ .elem("availabilityZone", host.getAvailabilityZone())+ .elem("autoPlacement", host.getAutoPlacement())+ .elem("hostRecovery", host.getHostRecovery())+ .elem("hostMaintenance", host.getHostMaintenance())+ .elem("state", host.getState())+ .elem("outpostArn", host.getOutpostArn())+ .elem("assetId", host.getAssetId())+ .elem("allocationTime", host.getAllocationTime() != null ? ISO_FMT.format(host.getAllocationTime()) : null)+ .elem("releaseTime", host.getReleaseTime() != null ? ISO_FMT.format(host.getReleaseTime()) : null)+ .start("hostProperties")+ .elem("instanceFamily", host.getInstanceFamily())+ .elem("instanceType", host.getInstanceType())+ .elem("sockets", 2)+ .elem("cores", 48)+ .elem("totalVCpus", 96)+ .end("hostProperties")+ .start("instances");+ for (Instance inst : service.hostInstances(region, host.getHostId())) {+ xml.start("item")+ .elem("instanceId", inst.getInstanceId())+ .elem("instanceType", inst.getInstanceType())+ .elem("ownerId", host.getOwnerId())+ .end("item");+ }+ xml.end("instances").raw(tagSetXml(host.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) {@@ -4541,6 +4667,7 @@ public class Ec2QueryHandler {xml.start("placement").elem("availabilityZone", inst.getPlacement().getAvailabilityZone()).elem("tenancy", inst.getPlacement().getTenancy())+ .elem("hostId", inst.getPlacement().getHostId()).end("placement");}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 1e5ebc2a10..8008419b7f 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@@ -23,6 +23,7 @@ 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.model.Host;import io.github.hectorvent.floci.services.ec2.model.IamInstanceProfileAssociation;import io.github.hectorvent.floci.services.ec2.model.Image;import io.github.hectorvent.floci.services.ec2.model.Instance;@@ -105,6 +106,7 @@ import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;import java.time.temporal.ChronoUnit;import java.util.ArrayList;+import java.util.Arrays;import java.util.Base64;import java.util.Collection;import java.util.Collections;@@ -259,6 +261,10 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {// resourceId → List<Tag>private final StorageBackend<String, List<Tag>> tags;private final StorageBackend<String, CapacityReservation> capacityReservations;+ private final StorageBackend<String, Host> hosts;+ // Serialises a launch onto a host against ModifyHosts/ReleaseHosts, so a host cannot be+ // released between the launch's availability check and the store of its instance.+ private final Object hostLock = new Object();private final Set<String> seededAccountRegions = ConcurrentHashMap.newKeySet();// region::subnetId → offset the next synthesised address is tried at. Only an ordering hint:// restart forgets it, and privateIpsInUse is what keeps addresses from being handed out twice.@@ -460,7 +466,8 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {new TypeReference<Map<String, CapacityReservation>>() {}),storageFactory.create("ec2", "ec2-volume-modifications.json",new TypeReference<Map<String, VolumeModification>>() {}),- requestContextInstance, iamService, volumeBlockDeviceManager);+ requestContextInstance, iamService, volumeBlockDeviceManager,+ storageFactory.create("ec2", "ec2-hosts.json", new TypeReference<Map<String, Host>>() {}));}// Package-private for hermetic tests (pass in-memory or temp-dir-backed StorageBackends directly).@@ -659,6 +666,56 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {jakarta.enterprise.inject.Instance<RequestContext> requestContextInstance,IamService iamService,Ec2VolumeBlockDeviceManager volumeBlockDeviceManager) {+ this(config, containerManager, portForwardManager, amiImageResolver, imageCatalog,+ instanceTypeCatalog, vpcs, subnets, securityGroups, securityGroupRules,+ internetGateways, routeTables, keyPairs, addresses, instances,+ volumes, registeredImages, snapshots, launchTemplates, vpcEndpoints,+ natGateways, spotInstanceRequests, networkAcls, managedPrefixLists, tags,+ transitGateways, transitGatewayRouteTables, transitGatewayVpcAttachments,+ transitGatewayPropagations, transitGatewayRoutes, vpcPeeringConnections,+ networkInterfaces, capacityReservations, volumeModifications,+ requestContextInstance, iamService, volumeBlockDeviceManager, new InMemoryStorage<>());+ }++ // The terminal constructor. Dedicated Hosts ride on their own parameter so the shorter+ // overloads above keep their arity for existing fixtures.+ Ec2Service(EmulatorConfig config, Ec2ContainerManager containerManager,+ Ec2PortForwardManager portForwardManager,+ AmiImageResolver amiImageResolver, Ec2ImageCatalog imageCatalog,+ Ec2InstanceTypeCatalog instanceTypeCatalog,+ StorageBackend<String, Vpc> vpcs,+ StorageBackend<String, Subnet> subnets,+ StorageBackend<String, SecurityGroup> securityGroups,+ StorageBackend<String, SecurityGroupRule> securityGroupRules,+ StorageBackend<String, InternetGateway> internetGateways,+ StorageBackend<String, RouteTable> routeTables,+ StorageBackend<String, KeyPair> keyPairs,+ StorageBackend<String, Address> addresses,+ StorageBackend<String, Instance> instances,+ StorageBackend<String, Volume> volumes,+ StorageBackend<String, Image> registeredImages,+ StorageBackend<String, Snapshot> snapshots,+ StorageBackend<String, LaunchTemplate> launchTemplates,+ StorageBackend<String, VpcEndpoint> vpcEndpoints,+ StorageBackend<String, NatGateway> natGateways,+ StorageBackend<String, SpotInstanceRequest> spotInstanceRequests,+ StorageBackend<String, NetworkAcl> networkAcls,+ StorageBackend<String, ManagedPrefixList> managedPrefixLists,+ StorageBackend<String, List<Tag>> tags,+ StorageBackend<String, TransitGateway> transitGateways,+ StorageBackend<String, TransitGatewayRouteTable> transitGatewayRouteTables,+ StorageBackend<String, TransitGatewayVpcAttachment> transitGatewayVpcAttachments,+ StorageBackend<String, TransitGatewayRouteTablePropagation> transitGatewayPropagations,+ StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes,+ StorageBackend<String, VpcPeeringConnection> vpcPeeringConnections,+ StorageBackend<String, NetworkInterface> networkInterfaces,+ StorageBackend<String, CapacityReservation> capacityReservations,+ StorageBackend<String, VolumeModification> volumeModifications,+ jakarta.enterprise.inject.Instance<RequestContext> requestContextInstance,+ IamService iamService,+ Ec2VolumeBlockDeviceManager volumeBlockDeviceManager,+ StorageBackend<String, Host> hosts) {+ this.hosts = hosts;this.iamService = iamService;this.volumeBlockDeviceManager = volumeBlockDeviceManager;this.defaultAccountId = config.defaultAccountId();@@ -2893,6 +2950,40 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {int networkInterfaceDeviceIndex, String availabilityZone,LaunchTemplateData.MetadataOptions metadataOptions,String creditSpecificationCpuCredits, String encodedUserData, boolean dryRun) {+ return runInstances(region, imageId, instanceType, minCount, maxCount, keyName,+ securityGroupIds, subnetId, clientToken, instanceTags, userData, iamInstanceProfileArn,+ associatePublicIp, networkInterfaceId, networkInterfaceDeviceIndex, availabilityZone,+ metadataOptions, creditSpecificationCpuCredits, encodedUserData, dryRun, null, null);+ }++ /**+ * @param hostId Placement.HostId: the Dedicated Host to launch onto. It must exist and not be+ * released; with no subnet or zone named, the launch lands in the host's zone.+ * @param tenancy Placement.Tenancy; defaults to {@code host} when a host is named.+ */+ public Reservation runInstances(String region, String imageId, String instanceType,+ int minCount, int maxCount, String keyName,+ List<String> securityGroupIds, String subnetId,+ String clientToken, List<Tag> instanceTags,+ String userData, String iamInstanceProfileArn,+ Boolean associatePublicIp, String networkInterfaceId,+ int networkInterfaceDeviceIndex, String availabilityZone,+ LaunchTemplateData.MetadataOptions metadataOptions,+ String creditSpecificationCpuCredits, String encodedUserData, boolean dryRun,+ String hostId, String tenancy) {+ if (hostId != null && !hostId.isBlank()) {+ Host host = getRequiredAvailableHost(region, hostId);+ if ((availabilityZone == null || availabilityZone.isBlank())+ && (subnetId == null || subnetId.isBlank())+ && (networkInterfaceId == null || networkInterfaceId.isBlank())) {+ availabilityZone = host.getAvailabilityZone();+ }+ if (tenancy == null || tenancy.isBlank()) {+ tenancy = "host";+ }+ } else {+ hostId = null;+ }if (imageId == null || imageId.isBlank()) {throw new AwsException("MissingParameter", "The request must contain the parameter ImageId", 400);}@@ -2970,6 +3061,9 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {reservation.setOwnerId(callerAccountId());String effectiveInstanceType = instanceType != null ? instanceType : "t2.micro";+ if (hostId != null) {+ validateHostPlacement(getRequiredAvailableHost(region, hostId), az, effectiveInstanceType, tenancy);+ }validateArchitectureCompatibility(region, imageId, effectiveInstanceType);int count = Math.min(maxCount, Math.max(minCount, 1));String architecture = architectureFor(region, imageId, effectiveInstanceType);@@ -3007,112 +3101,124 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {throw new AwsException("DryRunOperation", "Request would have succeeded, but DryRun flag is set.", 412);}synchronized (privateIpAllocationLock) {- List<String> privateIps = allocateLaunchAddresses(region, finalSubnetId, suppliedEni, count);- for (int i = 0; i < count; i++) {- String instanceId = "i-" + randomHex(17);- String privateIp = privateIps.get(i);-- Instance inst = new Instance();- inst.setInstanceId(instanceId);- inst.setImageId(imageId);- inst.setState(InstanceState.pending());- inst.setInstanceType(effectiveInstanceType);- inst.setPlacement(new Placement(az));- inst.setSubnetId(finalSubnetId);- inst.setVpcId(vpcId);- // AWS precedence (#1984): the launch-time AssociatePublicIpAddress- // override wins in both directions; the subnet's MapPublicIpOnLaunch- // attribute is only the default when the launch does not specify it.- inst.setAssociatePublicIp(associatePublicIp != null- ? associatePublicIp- : subnet != null && subnet.isMapPublicIpOnLaunch());- inst.setPrivateIpAddress(privateIp);- inst.setPrivateDnsName("ip-" + privateIp.replace('.', '-') + ".ec2.internal");- inst.setKeyName(keyName);- inst.setSecurityGroups(new ArrayList<>(sgIdentifiers));- inst.setArchitecture(architecture);- inst.setLaunchTime(Instant.now());- inst.setAmiLaunchIndex(i);- inst.setClientToken(clientToken);- inst.setRegion(region);- inst.setUserData(userData);- inst.setEncodedUserData(encodedUserData);- inst.setIamInstanceProfileArn(iamInstanceProfileArn);- if (iamInstanceProfileArn != null) {- inst.setIamInstanceProfileAssociationTime(inst.getLaunchTime());- }- inst.setMetadataOptions(LaunchTemplateData.MetadataOptions.merge(launchMetadataOptions, null));- inst.setCreditSpecificationCpuCredits(- acquiredCpuCredits(effectiveInstanceType, creditSpecificationCpuCredits));- if (instanceTags != null && !instanceTags.isEmpty()) {- inst.setTags(new ArrayList<>(instanceTags));- tags.put(instanceId, new ArrayList<>(instanceTags));+ synchronized (hostLock) {+ if (hostId != null) {+ // Re-checked under hostLock: a ReleaseHosts or ModifyHosts may have landed+ // since the unlocked check above.+ validateHostPlacement(getRequiredAvailableHost(region, hostId), az, effectiveInstanceType, tenancy);}+ List<String> privateIps = allocateLaunchAddresses(region, finalSubnetId, suppliedEni, count);+ for (int i = 0; i < count; i++) {+ String instanceId = "i-" + randomHex(17);+ String privateIp = privateIps.get(i);++ Instance inst = new Instance();+ inst.setInstanceId(instanceId);+ inst.setImageId(imageId);+ inst.setState(InstanceState.pending());+ inst.setInstanceType(effectiveInstanceType);+ Placement placement = new Placement(az);+ placement.setHostId(hostId);+ if (tenancy != null && !tenancy.isBlank()) {+ placement.setTenancy(tenancy);+ }+ inst.setPlacement(placement);+ inst.setSubnetId(finalSubnetId);+ inst.setVpcId(vpcId);+ // AWS precedence (#1984): the launch-time AssociatePublicIpAddress+ // override wins in both directions; the subnet's MapPublicIpOnLaunch+ // attribute is only the default when the launch does not specify it.+ inst.setAssociatePublicIp(associatePublicIp != null+ ? associatePublicIp+ : subnet != null && subnet.isMapPublicIpOnLaunch());+ inst.setPrivateIpAddress(privateIp);+ inst.setPrivateDnsName("ip-" + privateIp.replace('.', '-') + ".ec2.internal");+ inst.setKeyName(keyName);+ inst.setSecurityGroups(new ArrayList<>(sgIdentifiers));+ inst.setArchitecture(architecture);+ inst.setLaunchTime(Instant.now());+ inst.setAmiLaunchIndex(i);+ inst.setClientToken(clientToken);+ inst.setRegion(region);+ inst.setUserData(userData);+ inst.setEncodedUserData(encodedUserData);+ inst.setIamInstanceProfileArn(iamInstanceProfileArn);+ if (iamInstanceProfileArn != null) {+ inst.setIamInstanceProfileAssociationTime(inst.getLaunchTime());+ }+ inst.setMetadataOptions(LaunchTemplateData.MetadataOptions.merge(launchMetadataOptions, null));+ inst.setCreditSpecificationCpuCredits(+ acquiredCpuCredits(effectiveInstanceType, creditSpecificationCpuCredits));+ if (instanceTags != null && !instanceTags.isEmpty()) {+ inst.setTags(new ArrayList<>(instanceTags));+ tags.put(instanceId, new ArrayList<>(instanceTags));+ }- // Network interface, either the caller-supplied standalone ENI (override-default-eni,- // floci-kt9) or a freshly-minted implicit primary interface.- InstanceNetworkInterface eni = new InstanceNetworkInterface();- eni.setNetworkInterfaceId(suppliedEni != null- ? suppliedEni.getNetworkInterfaceId()- : "eni-" + randomHex(17));- eni.setSubnetId(finalSubnetId);- eni.setVpcId(vpcId);- eni.setOwnerId(callerAccountId());- eni.setDescription(suppliedEni != null ? suppliedEni.getDescription() : null);- eni.setMacAddress(suppliedEni != null ? suppliedEni.getMacAddress() : null);- eni.setPrivateIpAddress(privateIp);- eni.setPrivateDnsName(inst.getPrivateDnsName());- eni.setGroups(new ArrayList<>(sgIdentifiers));- eni.setAttachmentId("eni-attach-" + randomHex(17));- eni.setDeviceIndex(suppliedEni != null ? networkInterfaceDeviceIndex : 0);- if (inst.getLaunchTime() != null) {- eni.setAttachTime(ISO_FMT.format(inst.getLaunchTime()));- }- inst.getNetworkInterfaces().add(eni);- if (suppliedEni != null) {- // The standalone record stays authoritative rather than being folded into the- // instance: AWS defaults deleteOnTermination to false for an interface the caller- // created and handed to a launch, so it outlives the instance and returns to- // "available" on termination instead of vanishing with it. Double-counting is- // avoided in describeNetworkInterfaces, which skips the instance-side copy of any- // id the standalone store owns.- NetworkInterfaceAttachment launchAttachment = new NetworkInterfaceAttachment();- launchAttachment.setAttachmentId(eni.getAttachmentId());- launchAttachment.setDeviceIndex(eni.getDeviceIndex());- launchAttachment.setStatus("attached");- launchAttachment.setInstanceId(instanceId);- launchAttachment.setInstanceOwnerId(callerAccountId());- launchAttachment.setAttachTime(eni.getAttachTime());- launchAttachment.setDeleteOnTermination(false);- suppliedEni.setAttachment(launchAttachment);- suppliedEni.setStatus("in-use");- networkInterfaces.put(key(region, suppliedEni.getNetworkInterfaceId()), suppliedEni);- }+ // Network interface, either the caller-supplied standalone ENI (override-default-eni,+ // floci-kt9) or a freshly-minted implicit primary interface.+ InstanceNetworkInterface eni = new InstanceNetworkInterface();+ eni.setNetworkInterfaceId(suppliedEni != null+ ? suppliedEni.getNetworkInterfaceId()+ : "eni-" + randomHex(17));+ eni.setSubnetId(finalSubnetId);+ eni.setVpcId(vpcId);+ eni.setOwnerId(callerAccountId());+ eni.setDescription(suppliedEni != null ? suppliedEni.getDescription() : null);+ eni.setMacAddress(suppliedEni != null ? suppliedEni.getMacAddress() : null);+ eni.setPrivateIpAddress(privateIp);+ eni.setPrivateDnsName(inst.getPrivateDnsName());+ eni.setGroups(new ArrayList<>(sgIdentifiers));+ eni.setAttachmentId("eni-attach-" + randomHex(17));+ eni.setDeviceIndex(suppliedEni != null ? networkInterfaceDeviceIndex : 0);+ if (inst.getLaunchTime() != null) {+ eni.setAttachTime(ISO_FMT.format(inst.getLaunchTime()));+ }+ inst.getNetworkInterfaces().add(eni);+ if (suppliedEni != null) {+ // The standalone record stays authoritative rather than being folded into the+ // instance: AWS defaults deleteOnTermination to false for an interface the caller+ // created and handed to a launch, so it outlives the instance and returns to+ // "available" on termination instead of vanishing with it. Double-counting is+ // avoided in describeNetworkInterfaces, which skips the instance-side copy of any+ // id the standalone store owns.+ NetworkInterfaceAttachment launchAttachment = new NetworkInterfaceAttachment();+ launchAttachment.setAttachmentId(eni.getAttachmentId());+ launchAttachment.setDeviceIndex(eni.getDeviceIndex());+ launchAttachment.setStatus("attached");+ launchAttachment.setInstanceId(instanceId);+ launchAttachment.setInstanceOwnerId(callerAccountId());+ launchAttachment.setAttachTime(eni.getAttachTime());+ launchAttachment.setDeleteOnTermination(false);+ suppliedEni.setAttachment(launchAttachment);+ suppliedEni.setStatus("in-use");+ networkInterfaces.put(key(region, suppliedEni.getNetworkInterfaceId()), suppliedEni);+ }- // Root EBS volume- String rootVolId = "vol-" + randomHex(17);- inst.setRootVolumeId(rootVolId);- Volume rootVol = new Volume();- rootVol.setVolumeId(rootVolId);- rootVol.setAvailabilityZone(az);- rootVol.setVolumeType(DEFAULT_ROOT_VOLUME_TYPE);- rootVol.setSize(DEFAULT_ROOT_VOLUME_SIZE_GIB);- rootVol.setState("in-use");- rootVol.setRegion(region);- rootVol.setCreateTime(Instant.now());- VolumeAttachment att = new VolumeAttachment();- att.setVolumeId(rootVolId);- att.setInstanceId(instanceId);- att.setDevice(inst.getRootDeviceName());- att.setState("attached");- att.setDeleteOnTermination(true);- att.setAttachTime(Instant.now());- rootVol.getAttachments().add(att);- volumes.put(key(region, rootVolId), rootVol);-- instances.put(key(region, instanceId), inst);- launched.add(inst);- reservation.getInstances().add(inst);+ // Root EBS volume+ String rootVolId = "vol-" + randomHex(17);+ inst.setRootVolumeId(rootVolId);+ Volume rootVol = new Volume();+ rootVol.setVolumeId(rootVolId);+ rootVol.setAvailabilityZone(az);+ rootVol.setVolumeType(DEFAULT_ROOT_VOLUME_TYPE);+ rootVol.setSize(DEFAULT_ROOT_VOLUME_SIZE_GIB);+ rootVol.setState("in-use");+ rootVol.setRegion(region);+ rootVol.setCreateTime(Instant.now());+ VolumeAttachment att = new VolumeAttachment();+ att.setVolumeId(rootVolId);+ att.setInstanceId(instanceId);+ att.setDevice(inst.getRootDeviceName());+ att.setState("attached");+ att.setDeleteOnTermination(true);+ att.setAttachTime(Instant.now());+ rootVol.getAttachments().add(att);+ volumes.put(key(region, rootVolId), rootVol);++ instances.put(key(region, instanceId), inst);+ launched.add(inst);+ reservation.getInstances().add(inst);+ }}}}@@ -7099,6 +7205,12 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {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; }+ Host host = hosts.get(storeKey).orElse(null);+ if (host != null) {+ host.setTags(new ArrayList<>(tagList));+ hosts.put(storeKey, host);+ 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);@@ -7227,6 +7339,9 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {if (resourceId.startsWith("cr-")) {return "capacity-reservation";}+ if (resourceId.startsWith("h-")) {+ return "dedicated-host";+ }if (resourceId.startsWith("vpc-")) {return "vpc";}@@ -7470,6 +7585,179 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {return reservation;}+ // ─── Dedicated Hosts ───────────────────────────────────────────────────────++ public List<Host> allocateHosts(String region, String availabilityZone, String instanceType,+ String instanceFamily, Integer quantity, String autoPlacement, String hostRecovery,+ String hostMaintenance, String outpostArn, String assetId) {+ ensureDefaultResources(region);+ if (availabilityZone == null || availabilityZone.isBlank()) {+ throw new AwsException("MissingParameter",+ "The request must contain the parameter AvailabilityZone.", 400);+ }+ boolean hasType = instanceType != null && !instanceType.isBlank();+ boolean hasFamily = instanceFamily != null && !instanceFamily.isBlank();+ if (hasType == hasFamily) {+ throw new AwsException("InvalidParameterCombination",+ "Specify exactly one of InstanceType or InstanceFamily.", 400);+ }+ int count = quantity == null ? 1 : quantity;+ if (count <= 0) {+ throw new AwsException("InvalidParameterValue",+ "Value (" + count + ") for parameter Quantity is invalid.", 400);+ }+ validateHostSettings(autoPlacement, hostRecovery, hostMaintenance);+ boolean zoneExists = Arrays.stream(MODELLED_ZONE_SUFFIXES)+ .anyMatch(suffix -> availabilityZone.equals(region + suffix));+ if (!zoneExists) {+ throw new AwsException("InvalidParameterValue",+ "Invalid availability zone: [" + availabilityZone + "]", 400);+ }+ List<Host> allocated = new ArrayList<>();+ for (int i = 0; i < count; i++) {+ Host host = new Host();+ host.setHostId("h-" + randomHex(17));+ host.setOwnerId(callerAccountId());+ host.setRegion(region);+ host.setAvailabilityZone(availabilityZone);+ host.setInstanceType(hasType ? instanceType : null);+ host.setInstanceFamily(hasFamily ? instanceFamily : null);+ if (autoPlacement != null) {+ host.setAutoPlacement(autoPlacement);+ }+ if (hostRecovery != null) {+ host.setHostRecovery(hostRecovery);+ }+ if (hostMaintenance != null) {+ host.setHostMaintenance(hostMaintenance);+ }+ host.setOutpostArn(outpostArn);+ host.setAssetId(assetId);+ host.setAllocationTime(Instant.now());+ hosts.put(key(region, host.getHostId()), host);+ allocated.add(host);+ }+ return allocated;+ }++ public List<Host> describeHosts(String region, List<String> ids, Map<String, List<String>> filters) {+ ensureDefaultResources(region);+ for (String id : ids) {+ getRequiredHost(region, id);+ }+ return hosts.scan(k -> true).stream()+ .filter(h -> h.getRegion().equals(region))+ .filter(h -> ids.isEmpty() || ids.contains(h.getHostId()))+ .filter(h -> matchesFilters(h, filters, region))+ .collect(Collectors.toList());+ }++ /** Instances placed on the host that still occupy it, i.e. not shutting down or terminated. */+ public List<Instance> hostInstances(String region, String hostId) {+ return instances.scan(k -> true).stream()+ .filter(i -> region.equals(i.getRegion()))+ .filter(i -> i.getPlacement() != null && hostId.equals(i.getPlacement().getHostId()))+ .filter(i -> i.getState() == null+ || !List.of("shutting-down", "terminated").contains(i.getState().getName()))+ .collect(Collectors.toList());+ }++ /** One host of a ModifyHosts batch; the caller reports a throw as that id's unsuccessful item. */+ public void modifyHost(String region, String hostId, String autoPlacement, String hostRecovery,+ String hostMaintenance, String instanceType, String instanceFamily) {+ validateHostSettings(autoPlacement, hostRecovery, hostMaintenance);+ synchronized (hostLock) {+ Host host = getRequiredAvailableHost(region, hostId);+ if (autoPlacement != null) {+ host.setAutoPlacement(autoPlacement);+ }+ if (hostRecovery != null) {+ host.setHostRecovery(hostRecovery);+ }+ if (hostMaintenance != null) {+ host.setHostMaintenance(hostMaintenance);+ }+ if (instanceType != null) {+ host.setInstanceType(instanceType);+ host.setInstanceFamily(null);+ } else if (instanceFamily != null) {+ host.setInstanceFamily(instanceFamily);+ host.setInstanceType(null);+ }+ hosts.put(key(region, hostId), host);+ }+ }++ /** AutoPlacement, HostRecovery and HostMaintenance each take only on or off. */+ public void validateHostSettings(String autoPlacement, String hostRecovery, String hostMaintenance) {+ String[][] settings = {{"AutoPlacement", autoPlacement}, {"HostRecovery", hostRecovery},+ {"HostMaintenance", hostMaintenance}};+ for (String[] setting : settings) {+ if (setting[1] != null && !setting[1].equals("on") && !setting[1].equals("off")) {+ throw new AwsException("InvalidParameterValue",+ "Value (" + setting[1] + ") for parameter " + setting[0] + " is invalid.", 400);+ }+ }+ }++ // A launch onto a host must land in the host's zone, with host tenancy, on a type it accepts.+ private void validateHostPlacement(Host host, String az, String instanceType, String tenancy) {+ if (!host.getAvailabilityZone().equals(az)) {+ throw new AwsException("InvalidParameterCombination",+ "The Dedicated Host " + host.getHostId() + " is in availability zone '"+ + host.getAvailabilityZone() + "', not '" + az + "'.", 400);+ }+ if (tenancy != null && !tenancy.isBlank() && !"host".equals(tenancy)) {+ throw new AwsException("InvalidParameterCombination",+ "Tenancy '" + tenancy + "' cannot be combined with a Dedicated Host placement.", 400);+ }+ boolean typeOk = host.getInstanceType() != null+ ? host.getInstanceType().equals(instanceType)+ : host.getInstanceFamily() == null+ || instanceType.startsWith(host.getInstanceFamily() + ".");+ if (!typeOk) {+ throw new AwsException("InvalidParameter",+ "The instance type " + instanceType + " is not supported on Dedicated Host "+ + host.getHostId() + ".", 400);+ }+ }++ /**+ * One host of a ReleaseHosts batch. The record is kept with state {@code released}, which is+ * how AWS reports it afterwards, and a host still carrying instances cannot be released.+ */+ public void releaseHost(String region, String hostId) {+ synchronized (hostLock) {+ Host host = getRequiredAvailableHost(region, hostId);+ if (!hostInstances(region, hostId).isEmpty()) {+ throw new AwsException("InvalidHost.Occupied",+ "Dedicated host '" + hostId + "' cannot be released as it is occupied.", 400);+ }+ host.setState("released");+ host.setReleaseTime(Instant.now());+ hosts.put(key(region, hostId), host);+ }+ }++ // A released host is still describable but is gone for every other purpose.+ private Host getRequiredAvailableHost(String region, String hostId) {+ Host host = getRequiredHost(region, hostId);+ if ("released".equals(host.getState())) {+ throw new AwsException("InvalidHostID.NotFound",+ "The specified Dedicated Host ID '" + hostId + "' does not exist.", 400);+ }+ return host;+ }++ private Host getRequiredHost(String region, String hostId) {+ Host host = hostId == null ? null : hosts.get(key(region, hostId)).orElse(null);+ if (host == null) {+ throw new AwsException("InvalidHostID.NotFound",+ "The specified Dedicated Host ID '" + hostId + "' does not exist.", 400);+ }+ return host;+ }+// ─── Route Tables ──────────────────────────────────────────────────────────public RouteTable createRouteTable(String region, String vpcId) {@@ -8924,6 +9212,15 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {default -> true;};}+ if (resource instanceof Host host) {+ return switch (filterName) {+ case "availability-zone" -> matchesValue(values, host.getAvailabilityZone());+ case "instance-type" -> matchesValue(values, host.getInstanceType());+ case "state" -> matchesValue(values, host.getState());+ case "auto-placement" -> matchesValue(values, host.getAutoPlacement());+ default -> true;+ };+ }return true;}@@ -8948,6 +9245,9 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {if (resource instanceof TransitGatewayVpcAttachment attachment) return attachment.getTags();if (resource instanceof VpcPeeringConnection pcx) return pcx.getTags();if (resource instanceof CapacityReservation cr) return cr.getTags();+ if (resource instanceof Host host) {+ return host.getTags();+ }return Collections.emptyList();}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/Host.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Host.javanew file mode 100644index 0000000000..5a2cc53dab--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Host.java@@ -0,0 +1,85 @@+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;++/**+ * An EC2 Dedicated Host from {@code AllocateHosts}. Real AWS allocates synchronously enough+ * that the host is {@code available} on the first describe; it is reported that way here too.+ * A released host stays in {@code DescribeHosts} with state {@code released}, as on AWS.+ *+ * <p>Exactly one of {@code instanceFamily}/{@code instanceType} is set, whichever the caller+ * allocated with: the AWS provider treats both as optional non-computed arguments, so echoing+ * one it did not send would be a perpetual diff.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class Host {++ private String hostId;+ private String ownerId;+ private String region;+ private String availabilityZone;+ private String instanceFamily;+ private String instanceType;+ private String autoPlacement = "off";+ private String hostRecovery = "off";+ private String hostMaintenance = "on";+ private String outpostArn;+ private String assetId;+ private String state = "available";+ private Instant allocationTime;+ private Instant releaseTime;+ private List<Tag> tags = new ArrayList<>();++ public Host() {}++ public String getHostId() { return hostId; }+ public void setHostId(String hostId) { this.hostId = hostId; }++ public String getOwnerId() { return ownerId; }+ public void setOwnerId(String ownerId) { this.ownerId = ownerId; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public String getAvailabilityZone() { return availabilityZone; }+ public void setAvailabilityZone(String availabilityZone) { this.availabilityZone = availabilityZone; }++ public String getInstanceFamily() { return instanceFamily; }+ public void setInstanceFamily(String instanceFamily) { this.instanceFamily = instanceFamily; }++ public String getInstanceType() { return instanceType; }+ public void setInstanceType(String instanceType) { this.instanceType = instanceType; }++ public String getAutoPlacement() { return autoPlacement; }+ public void setAutoPlacement(String autoPlacement) { this.autoPlacement = autoPlacement; }++ public String getHostRecovery() { return hostRecovery; }+ public void setHostRecovery(String hostRecovery) { this.hostRecovery = hostRecovery; }++ public String getHostMaintenance() { return hostMaintenance; }+ public void setHostMaintenance(String hostMaintenance) { this.hostMaintenance = hostMaintenance; }++ public String getOutpostArn() { return outpostArn; }+ public void setOutpostArn(String outpostArn) { this.outpostArn = outpostArn; }++ public String getAssetId() { return assetId; }+ public void setAssetId(String assetId) { this.assetId = assetId; }++ public String getState() { return state; }+ public void setState(String state) { this.state = state; }++ public Instant getAllocationTime() { return allocationTime; }+ public void setAllocationTime(Instant allocationTime) { this.allocationTime = allocationTime; }++ public Instant getReleaseTime() { return releaseTime; }+ public void setReleaseTime(Instant releaseTime) { this.releaseTime = releaseTime; }++ public List<Tag> getTags() { return tags; }+ public void setTags(List<Tag> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/Placement.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Placement.javaindex 3f1d7b0867..72d6a66964 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/model/Placement.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Placement.java@@ -10,6 +10,7 @@ public class Placement {private String availabilityZone;private String tenancy = "default";private String groupName;+ private String hostId;public Placement() {}@@ -25,4 +26,7 @@ public class Placement {public String getGroupName() { return groupName; }public void setGroupName(String groupName) { this.groupName = groupName; }++ public String getHostId() { return hostId; }+ public void setHostId(String hostId) { this.hostId = hostId; }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2DedicatedHostIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2DedicatedHostIntegrationTest.javanew file mode 100644index 0000000000..a1a6c2be7e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2DedicatedHostIntegrationTest.java@@ -0,0 +1,321 @@+package io.github.hectorvent.floci.services.ec2;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import io.restassured.specification.RequestSpecification;+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 java.util.Arrays;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.startsWith;++/**+ * EC2 Dedicated Hosts over the Query protocol, walked through the lifecycle terraform's+ * {@code aws_ec2_host} drives: AllocateHosts, DescribeHosts until available, ModifyHosts,+ * ReleaseHosts, then DescribeHosts showing the host released. Each step is read back through+ * a separate DescribeHosts rather than trusting the mutating call's own response.+ *+ * <p>Ordered because the cases walk one host through its lifecycle.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class Ec2DedicatedHostIntegrationTest {++ private static final String AUTH_HEADER =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/ec2/aws4_request";++ private static String hostId;+ private static String instanceId;++ @Test+ @Order(1)+ void allocateReturnsAHostId() {+ hostId = given()+ .formParam("Action", "AllocateHosts")+ .formParam("InstanceType", "m5.large")+ .formParam("AvailabilityZone", "us-east-1a")+ .formParam("AutoPlacement", "off")+ .formParam("Quantity", "1")+ .formParam("TagSpecification.1.ResourceType", "dedicated-host")+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", "dh-test")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("AllocateHostsResponse.hostIdSet.item", startsWith("h-"))+ .extract().path("AllocateHostsResponse.hostIdSet.item");+ }++ @Test+ @Order(2)+ void describeShowsTheHostAvailableWithItsPropertiesAndTags() {+ given()+ .formParam("Action", "DescribeHosts")+ .formParam("HostId.1", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeHostsResponse.hostSet.item.hostId", equalTo(hostId))+ .body("DescribeHostsResponse.hostSet.item.state", equalTo("available"))+ .body("DescribeHostsResponse.hostSet.item.availabilityZone", equalTo("us-east-1a"))+ .body("DescribeHostsResponse.hostSet.item.autoPlacement", equalTo("off"))+ .body("DescribeHostsResponse.hostSet.item.hostRecovery", equalTo("off"))+ .body("DescribeHostsResponse.hostSet.item.ownerId", equalTo("000000000000"))+ .body("DescribeHostsResponse.hostSet.item.hostProperties.instanceType", equalTo("m5.large"))+ // Allocated by type, so no family is echoed: terraform would read it as drift.+ .body("DescribeHostsResponse.hostSet.item.hostProperties.instanceFamily.size()", equalTo(0))+ .body("DescribeHostsResponse.hostSet.item.tagSet.item.key", equalTo("Name"))+ .body("DescribeHostsResponse.hostSet.item.tagSet.item.value", equalTo("dh-test"));+ }++ @Test+ @Order(3)+ void modifyIsReadBackThroughDescribe() {+ given()+ .formParam("Action", "ModifyHosts")+ .formParam("HostId.1", hostId)+ .formParam("AutoPlacement", "on")+ .formParam("HostRecovery", "on")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyHostsResponse.successful.item", equalTo(hostId));++ given()+ .formParam("Action", "DescribeHosts")+ .formParam("HostId.1", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeHostsResponse.hostSet.item.autoPlacement", equalTo("on"))+ .body("DescribeHostsResponse.hostSet.item.hostRecovery", equalTo("on"));+ }++ @Test+ @Order(4)+ void runInstancesOnTheHostReportsPlacementAndOccupiesIt() {+ instanceId = given()+ .formParam("Action", "RunInstances")+ .formParam("ImageId", "ami-0abcdef1234567891")+ .formParam("InstanceType", "m5.large")+ .formParam("MinCount", "1")+ .formParam("MaxCount", "1")+ .formParam("Placement.HostId", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("RunInstancesResponse.instancesSet.item.instanceId");++ given()+ .formParam("Action", "DescribeInstances")+ .formParam("InstanceId.1", instanceId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.placement.hostId",+ equalTo(hostId))+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.placement.tenancy",+ equalTo("host"))+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.placement.availabilityZone",+ equalTo("us-east-1a"));++ given()+ .formParam("Action", "DescribeHosts")+ .formParam("HostId.1", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeHostsResponse.hostSet.item.instances.item.instanceId", equalTo(instanceId));+ }++ @Test+ @Order(5)+ void releaseOfAnOccupiedHostIsUnsuccessful() {+ given()+ .formParam("Action", "ReleaseHosts")+ .formParam("HostId.1", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ReleaseHostsResponse.unsuccessful.item.resourceId", equalTo(hostId))+ .body("ReleaseHostsResponse.unsuccessful.item.error.code", equalTo("Client.InvalidHost.Occupied"))+ .body("ReleaseHostsResponse.unsuccessful.item.error.message",+ equalTo("Dedicated host '" + hostId + "' cannot be released as it is occupied."));++ given()+ .formParam("Action", "TerminateInstances")+ .formParam("InstanceId.1", instanceId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(6)+ void releaseLeavesTheHostDescribableAsReleased() {+ given()+ .formParam("Action", "ReleaseHosts")+ .formParam("HostId.1", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ReleaseHostsResponse.successful.item", equalTo(hostId));++ given()+ .formParam("Action", "DescribeHosts")+ .formParam("HostId.1", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeHostsResponse.hostSet.item.state", equalTo("released"));+ }++ @Test+ @Order(7)+ void describeOfAnUnknownHostIsNotFound() {+ given()+ .formParam("Action", "DescribeHosts")+ .formParam("HostId.1", "h-00000000000000000")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidHostID.NotFound"))+ .body("Response.Errors.Error.Message", containsString("h-00000000000000000"));+ }++ @Test+ @Order(8)+ void releaseOfAnUnknownOrAlreadyReleasedHostIsUnsuccessfulNotAnError() {+ given()+ .formParam("Action", "ReleaseHosts")+ .formParam("HostId.1", "h-00000000000000000")+ .formParam("HostId.2", hostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ReleaseHostsResponse.unsuccessful.item.size()", equalTo(2))+ .body("ReleaseHostsResponse.unsuccessful.item[0].error.code", equalTo("Client.InvalidHostID.NotFound"))+ .body("ReleaseHostsResponse.unsuccessful.item[1].resourceId", equalTo(hostId));+ }++ @Test+ @Order(9)+ void allocationThatOmitsAutoPlacementDefaultsItToOff() {+ String defaultedHostId = given()+ .formParam("Action", "AllocateHosts")+ .formParam("InstanceFamily", "m5")+ .formParam("AvailabilityZone", "us-east-1a")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("AllocateHostsResponse.hostIdSet.item");++ given()+ .formParam("Action", "DescribeHosts")+ .formParam("HostId.1", defaultedHostId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeHostsResponse.hostSet.item.autoPlacement", equalTo("off"));+ }++ private static ValidatableResponse post(String... kv) {+ RequestSpecification r = given().header("Authorization", AUTH_HEADER);+ for (int i = 0; i < kv.length; i += 2) {+ r = r.formParam(kv[i], kv[i + 1]);+ }+ return r.when().post("/").then();+ }++ private static String allocate(String zone) {+ return post("Action", "AllocateHosts", "InstanceType", "m5.large", "AvailabilityZone", zone)+ .statusCode(200).extract().path("AllocateHostsResponse.hostIdSet.item");+ }++ private static int hostCount() {+ return post("Action", "DescribeHosts").statusCode(200)+ .extract().xmlPath().getList("DescribeHostsResponse.hostSet.item").size();+ }++ @Test+ @Order(10)+ void allocateRejectsANonexistentZoneAndStoresNothing() {+ int before = hostCount();+ post("Action", "AllocateHosts", "InstanceType", "m5.large", "AvailabilityZone", "us-east-1z")+ .statusCode(400).body(containsString("InvalidParameterValue"));+ org.junit.jupiter.api.Assertions.assertEquals(before, hostCount());+ }++ @Test+ @Order(11)+ void invalidHostSettingsAreRejectedOnAllocateAndModifyAndNotStored() {+ post("Action", "AllocateHosts", "InstanceType", "m5.large", "AvailabilityZone", "us-east-1a",+ "AutoPlacement", "banana").statusCode(400).body(containsString("InvalidParameterValue"));+ String id = allocate("us-east-1a");+ post("Action", "ModifyHosts", "HostId.1", id, "HostRecovery", "banana")+ .statusCode(400).body(containsString("InvalidParameterValue"));+ post("Action", "DescribeHosts", "HostId.1", id).statusCode(200)+ .body("DescribeHostsResponse.hostSet.item.hostRecovery", equalTo("off"));+ }++ @Test+ @Order(12)+ void launchPlacementThatContradictsTheHostIsRejected() {+ String id = allocate("us-east-1a");+ String subnetInB = post("Action", "DescribeSubnets", "Filter.1.Name", "availability-zone",+ "Filter.1.Value.1", "us-east-1b").statusCode(200)+ .extract().xmlPath().getList("DescribeSubnetsResponse.subnetSet.item.subnetId").get(0).toString();+ String[] base = {"Action", "RunInstances", "ImageId", "ami-0abcdef1234567891", "MinCount", "1",+ "MaxCount", "1", "Placement.HostId", id};+ post(concat(base, "InstanceType", "m5.large", "SubnetId", subnetInB))+ .statusCode(400).body("Response.Errors.Error.Code", equalTo("InvalidParameterCombination"));+ post(concat(base, "InstanceType", "m5.large", "Placement.Tenancy", "default"))+ .statusCode(400).body("Response.Errors.Error.Code", equalTo("InvalidParameterCombination"));+ post(concat(base, "InstanceType", "c5.large"))+ .statusCode(400).body("Response.Errors.Error.Code", equalTo("InvalidParameter"));+ post("Action", "DescribeHosts", "HostId.1", id).statusCode(200)+ .body("DescribeHostsResponse.hostSet.item.instances.item.size()", equalTo(0));+ }++ private static String[] concat(String[] a, String... b) {+ String[] out = Arrays.copyOf(a, a.length + b.length);+ System.arraycopy(b, 0, out, a.length, b.length);+ return out;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.javaindex 2885f903d4..7aeae110a8 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.java@@ -60,7 +60,8 @@ class Ec2RunInstancesPublicIpParamTest {anyInt(), anyInt(), nullable(String.class), anyList(), nullable(String.class),nullable(String.class), anyList(), nullable(String.class), nullable(String.class),nullable(Boolean.class), nullable(String.class), anyInt(), nullable(String.class),- nullable(LaunchTemplateData.MetadataOptions.class), nullable(String.class), nullable(String.class), eq(false)))+ nullable(LaunchTemplateData.MetadataOptions.class), nullable(String.class), nullable(String.class), eq(false),+ nullable(String.class), nullable(String.class))).thenReturn(new Reservation());Ec2QueryHandler handler = new Ec2QueryHandler(service, mock(EmulatorConfig.class),@@ -73,7 +74,8 @@ class Ec2RunInstancesPublicIpParamTest {anyInt(), anyInt(), nullable(String.class), anyList(), nullable(String.class),nullable(String.class), anyList(), nullable(String.class), nullable(String.class),associatePublicIp.capture(), nullable(String.class), anyInt(), nullable(String.class),- nullable(LaunchTemplateData.MetadataOptions.class), nullable(String.class), nullable(String.class), eq(false));+ nullable(LaunchTemplateData.MetadataOptions.class), nullable(String.class), nullable(String.class), eq(false),+ nullable(String.class), nullable(String.class));if (expected == null) {assertNull(associatePublicIp.getValue(),"an absent override must stay null so the subnet default decides");diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.javaindex 16633f4aa6..753e437f95 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java@@ -4898,4 +4898,52 @@ class Ec2ServiceTest {// Provider remains untouchedassertEquals(1, nodeInstance.getTags().size());}++ // The host is released after runInstances' unlocked availability check and before its instances+ // are stored. The instance-type catalog lookup sits between the two, so it stands in for the+ // concurrent ReleaseHosts. Only the re-check under hostLock can still reject the launch.+ @Test+ void launchOntoAHostReleasedAfterTheUnlockedCheckIsRejected() {+ Ec2Service[] holder = new Ec2Service[1];+ String[] hostId = new String[1];+ boolean[] released = {false};+ Ec2InstanceTypeCatalog releasingCatalog = new Ec2InstanceTypeCatalog() {+ @Override+ public Optional<CatalogInstanceType> find(String instanceType) {+ if (hostId[0] != null && !released[0]) {+ released[0] = true;+ holder[0].releaseHost("us-east-1", hostId[0]);+ }+ return super.find(instanceType);+ }+ };+ Ec2ImageCatalog imageCatalog = new Ec2ImageCatalog();+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), new AmiImageResolver(imageCatalog), imageCatalog,+ releasingCatalog, new InMemoryStorageFactory());+ holder[0] = service;+ hostId[0] = service.allocateHosts("us-east-1", "us-east-1a", "m5.large", null, 1,+ null, null, null, null, null).get(0).getHostId();++ AwsException e = assertThrows(AwsException.class, () -> service.runInstances("us-east-1",+ "ami-ubuntu2404-amd64", "m5.large", 1, 1, null, List.of(), null, null, List.of(), null, null,+ null, null, 0, null, null, null, null, false, hostId[0], null));++ assertTrue(released[0], "the hook must have released the host between the two checks");+ assertEquals("InvalidHostID.NotFound", e.getErrorCode());+ assertTrue(service.hostInstances("us-east-1", hostId[0]).isEmpty());+ }++ @Test+ void allocateHostsAcceptsModelledZoneWithNoSubnet() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class), mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class),+ new Ec2InstanceTypeCatalog(), new InMemoryStorageFactory());+ service.describeSubnets("us-east-1", List.of(), Map.of()).stream()+ .filter(sn -> "us-east-1c".equals(sn.getAvailabilityZone()))+ .forEach(sn -> service.deleteSubnet("us-east-1", sn.getSubnetId()));++ assertEquals(1, service.allocateHosts("us-east-1", "us-east-1c", "m5.large", null, 1,+ null, null, null, null, null).size());+ }}