Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ec2): place a subnet in the zone its request names, not always az1 (#2890)
Allen Sanbornc32f8b5a24fe
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 af1d3db6e9..42e7074388 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@@ -2291,7 +2291,8 @@ public class Ec2QueryHandler {String vpcId = p.getFirst("VpcId");String cidrBlock = p.getFirst("CidrBlock");String az = p.getFirst("AvailabilityZone");- Subnet subnet = service.createSubnet(region, vpcId, cidrBlock, az);+ String azId = p.getFirst("AvailabilityZoneId");+ Subnet subnet = service.createSubnet(region, vpcId, cidrBlock, az, azId);applyResourceTags(p, region, "subnet", subnet.getSubnetId());XmlBuilder xml = new XmlBuilder().start("CreateSubnetResponse", AwsNamespaces.EC2)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 34d9254e60..d1a98cd59b 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@@ -109,6 +109,13 @@ import jakarta.inject.Inject;public class Ec2Service implements ContainerTeardown, ResourceProvider {private static final Logger LOG = Logger.getLogger(Ec2Service.class);++ /**+ * The availability zones every region is modelled with. DescribeAvailabilityZones publishes+ * exactly these, the seeded default subnets sit in them, and CreateSubnet refuses a zone id+ * outside them, so the three cannot drift apart.+ */+ private static final String[] MODELLED_ZONE_SUFFIXES = {"a", "b", "c"};private static final DateTimeFormatter ISO_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneOffset.UTC);private static final int DEFAULT_ROOT_VOLUME_SIZE_GIB = 8;@@ -428,7 +435,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {vpcs.put(key(region, vpcId), defaultVpc);// Default subnets (a/b/c)- String[] azSuffixes = {"a", "b", "c"};+ String[] azSuffixes = MODELLED_ZONE_SUFFIXES;String[] cidrBlocks = {"172.31.0.0/20", "172.31.16.0/20", "172.31.32.0/20"};String[] subnetIds = {defaultSubnetId(region, azSuffixes[0]),@@ -441,7 +448,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {subnet.setCidrBlock(cidrBlocks[i]);subnet.setState("available");subnet.setAvailabilityZone(region + azSuffixes[i]);- subnet.setAvailabilityZoneId(region + "-az" + (i + 1));+ subnet.setAvailabilityZoneId(zoneIdForZoneName(region, region + azSuffixes[i]));subnet.setAvailableIpAddressCount(4091);subnet.setDefaultForAz(true);subnet.setMapPublicIpOnLaunch(true);@@ -3020,21 +3027,91 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {// ─── Subnets ───────────────────────────────────────────────────────────────+ /**+ * The zone id Floci publishes for a zone name. AWS's real zone ids are opaque and per-account+ * ({@code use1-az4}); Floci derives a deterministic one instead, and what matters is that+ * every surface derives it the same way, DescribeAvailabilityZones, the seeded default+ * subnets and CreateSubnet all come through here, so a subnet's zone id agrees with the zone+ * list a client just read. A zone name that is not this region's {@code <region><letter>}+ * keeps the first zone's id, which is what an unrecognised name resolved to before.+ */+ static String zoneIdForZoneName(String region, String zoneName) {+ if (zoneName != null && zoneName.length() == region.length() + 1 && zoneName.startsWith(region)) {+ char letter = Character.toLowerCase(zoneName.charAt(zoneName.length() - 1));+ if (letter >= 'a' && letter <= 'z') {+ return region + "-az" + (letter - 'a' + 1);+ }+ }+ return region + "-az1";+ }++ /**+ * Resolves the zone a new subnet lands in from whichever of AvailabilityZone and+ * AvailabilityZoneId the caller supplied. Terraform's aws_subnet exposes both+ * ({@code availability_zone} and {@code availability_zone_id}) and forbids setting both at+ * once, so in practice exactly one arrives; a pair that disagrees is refused rather than+ * silently resolved to one of them.+ */+ private String resolveSubnetZoneName(String region, String availabilityZone, String availabilityZoneId) {+ if (!isSet(availabilityZoneId)) {+ return isSet(availabilityZone) ? availabilityZone : region + "a";+ }+ String fromId = zoneNameForZoneId(region, availabilityZoneId);+ if (isSet(availabilityZone) && !availabilityZone.equals(fromId)) {+ throw new AwsException("InvalidParameterCombination",+ "The availability zone '" + availabilityZone + "' does not match the availability zone ID '"+ + availabilityZoneId + "'", 400);+ }+ return fromId;+ }++ /**+ * The inverse of {@link #zoneIdForZoneName}. An id outside the zones this region publishes is+ * refused rather than resolved: placing a subnet in a zone DescribeAvailabilityZones does not+ * list would leave a client unable to pair the two, which is the same inconsistency the+ * hardcoded az1 produced, only quieter.+ */+ private static String zoneNameForZoneId(String region, String availabilityZoneId) {+ String prefix = region + "-az";+ if (availabilityZoneId.startsWith(prefix)) {+ try {+ int index = Integer.parseInt(availabilityZoneId.substring(prefix.length()));+ if (index >= 1 && index <= MODELLED_ZONE_SUFFIXES.length) {+ return region + MODELLED_ZONE_SUFFIXES[index - 1];+ }+ } catch (NumberFormatException e) {+ LOG.debugv("Availability zone ID {0} has a non-numeric zone index: {1}",+ availabilityZoneId, e.getMessage());+ }+ }+ throw new AwsException("InvalidParameterValue",+ "Invalid availability zone ID: '" + availabilityZoneId + "'. This region publishes "+ + MODELLED_ZONE_SUFFIXES.length + " availability zones, " + prefix + "1 to "+ + prefix + MODELLED_ZONE_SUFFIXES.length + ".", 400);+ }+public Subnet createSubnet(String region, String vpcId, String cidrBlock, String availabilityZone) {+ return createSubnet(region, vpcId, cidrBlock, availabilityZone, null);+ }++ public Subnet createSubnet(String region, String vpcId, String cidrBlock, String availabilityZone,+ String availabilityZoneId) {if (vpcId == null || vpcId.isBlank()) {throw new AwsException("MissingParameter", "The request must contain the parameter VpcId", 400);}ensureDefaultResources(region);getRequiredVpc(region, vpcId);+ String zoneName = resolveSubnetZoneName(region, availabilityZone, availabilityZoneId);+String subnetId = "subnet-" + randomHex(8);Subnet subnet = new Subnet();subnet.setSubnetId(subnetId);subnet.setVpcId(vpcId);subnet.setCidrBlock(cidrBlock);subnet.setState("available");- subnet.setAvailabilityZone(availabilityZone != null ? availabilityZone : region + "a");- subnet.setAvailabilityZoneId(region + "-az1");+ subnet.setAvailabilityZone(zoneName);+ subnet.setAvailabilityZoneId(zoneIdForZoneName(region, zoneName));subnet.setAvailableIpAddressCount(251);subnet.setOwnerId(accountId);subnet.setRegion(region);@@ -5387,13 +5464,13 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {public List<Map<String, String>> describeAvailabilityZones(String region) {List<Map<String, String>> zones = new ArrayList<>();- String[] azSuffixes = {"a", "b", "c"};+ String[] azSuffixes = MODELLED_ZONE_SUFFIXES;for (String suffix : azSuffixes) {Map<String, String> az = new LinkedHashMap<>();az.put("zoneName", region + suffix);az.put("state", "available");az.put("regionName", region);- az.put("zoneId", region + "-az" + (suffix.charAt(0) - 'a' + 1));+ az.put("zoneId", zoneIdForZoneName(region, region + suffix));az.put("zoneType", "availability-zone");zones.add(az);}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2SubnetAvailabilityZoneIdIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2SubnetAvailabilityZoneIdIntegrationTest.javanew file mode 100644index 0000000000..9d053df81d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2SubnetAvailabilityZoneIdIntegrationTest.java@@ -0,0 +1,181 @@+package io.github.hectorvent.floci.services.ec2;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItem;++import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import io.quarkus.test.junit.QuarkusTest;++/**+ * CreateSubnet never read AvailabilityZoneId and hardcoded every new subnet's zone id to the+ * region's first zone, so a subnet asked for us-east-1-az2 came back in us-east-1-az1, and even+ * a subnet placed correctly by zone <em>name</em> reported a zone id that contradicted it.+ * Anything selecting subnets by zone id (Terraform's aws_subnet.availability_zone_id, and any+ * client pairing subnets with the DescribeAvailabilityZones list) therefore saw one zone.+ */+@QuarkusTest+class Ec2SubnetAvailabilityZoneIdIntegrationTest {++ private static final String AUTH_HEADER =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/ec2/aws4_request";++ private String vpcId;++ @BeforeEach+ void createVpc() {+ vpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.90.0.0/16")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");+ }++ @Test+ void theZoneIdFollowsTheZoneTheSubnetWasPlacedIn() {+ given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.90.1.0/24")+ .formParam("AvailabilityZone", "us-east-1b")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateSubnetResponse.subnet.availabilityZone", equalTo("us-east-1b"))+ .body("CreateSubnetResponse.subnet.availabilityZoneId", equalTo("us-east-1-az2"));+ }++ @Test+ void aSubnetCanBePlacedByZoneIdAlone() {+ String subnetId = given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.90.2.0/24")+ .formParam("AvailabilityZoneId", "us-east-1-az3")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateSubnetResponse.subnet.availabilityZoneId", equalTo("us-east-1-az3"))+ .body("CreateSubnetResponse.subnet.availabilityZone", equalTo("us-east-1c"))+ .extract().path("CreateSubnetResponse.subnet.subnetId");++ // ... and it reads back the same way, not just in the create response.+ given()+ .formParam("Action", "DescribeSubnets")+ .formParam("SubnetId.1", subnetId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeSubnetsResponse.subnetSet.item.availabilityZoneId", equalTo("us-east-1-az3"));+ }++ /**+ * The zone id a subnet reports has to be one DescribeAvailabilityZones actually publishes,+ * or a client that pairs the two lists finds no subnet in the zone it just looked up.+ */+ @Test+ void theZoneIdMatchesTheZoneListTheSameClientCanRead() {+ given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.90.3.0/24")+ .formParam("AvailabilityZone", "us-east-1c")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateSubnetResponse.subnet.availabilityZoneId", equalTo("us-east-1-az3"));++ given()+ .formParam("Action", "DescribeAvailabilityZones")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeAvailabilityZonesResponse.availabilityZoneInfo.item.zoneId",+ hasItem("us-east-1-az3"));+ }++ @Test+ void aZoneAndZoneIdThatDisagreeAreRefusedRatherThanSilentlyResolved() {+ given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.90.4.0/24")+ .formParam("AvailabilityZone", "us-east-1a")+ .formParam("AvailabilityZoneId", "us-east-1-az2")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterCombination"));+ }++ @Test+ void aZoneAndZoneIdNamingTheSameZoneAreAccepted() {+ given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.90.5.0/24")+ .formParam("AvailabilityZone", "us-east-1b")+ .formParam("AvailabilityZoneId", "us-east-1-az2")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateSubnetResponse.subnet.availabilityZone", equalTo("us-east-1b"));+ }++ /**+ * A well-formed id past the zones this region publishes is refused too. Resolving it would put+ * the subnet in a zone DescribeAvailabilityZones does not list, leaving a client unable to+ * pair the two: the same inconsistency the hardcoded az1 produced, only quieter.+ */+ @Test+ void aZoneIdBeyondThePublishedZonesIsRefused() {+ given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.90.7.0/24")+ .formParam("AvailabilityZoneId", "us-east-1-az4")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"))+ .body("Response.Errors.Error.Message", containsString("us-east-1-az1 to us-east-1-az3"));+ }++ @Test+ void aMalformedZoneIdIsRefused() {+ given()+ .formParam("Action", "CreateSubnet")+ .formParam("VpcId", vpcId)+ .formParam("CidrBlock", "10.90.6.0/24")+ .formParam("AvailabilityZoneId", "not-a-zone-id")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"));+ }+}