Light, fluffy, and always free - The AWS Local Emulator alternative
feat(core): derive ARN partition from the region (#3334)
Hector Venturadc61c1a8a59b
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.javaindex c2732d3154..fb9ca15f16 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsArnUtils.java@@ -19,11 +19,21 @@ public final class AwsArnUtils {public record Arn(String partition, String service, String region, String accountId, String resource) {/**- * Factory for standard AWS ARNs using the {@code aws} partition.- * Produces: {@code arn:aws:<service>:<region>:<accountId>:<resource>}+ * Factory for AWS ARNs, deriving the partition from the region.+ * Produces: {@code arn:<partition>:<service>:<region>:<accountId>:<resource>}+ *+ * <p>A resource in {@code cn-north-1} gets {@code aws-cn}, one in {@code us-gov-west-1}+ * gets {@code aws-us-gov}, and everything else gets {@code aws}. See+ * {@link AwsRegions#partitionFor}.+ *+ * <p>Global services pass an empty region and therefore keep {@code aws}. That is a known+ * gap rather than a decision: an IAM ARN in a GovCloud deployment really is+ * {@code arn:aws-us-gov:iam::…}, but nothing in the region argument can say so. Those call+ * sites need a partition from the deployment, not from the resource, and they are left+ * alone until there is one.*/public static Arn of(String service, String region, String accountId, String resource) {- return new Arn("aws", service, region, accountId, resource);+ return new Arn(AwsRegions.partitionFor(region), service, region, accountId, resource);}@Overridediff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsRegions.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsRegions.javaindex 4ad0947847..5f5cf5a345 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsRegions.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsRegions.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.core.common;import java.util.List;import java.util.Locale;import java.util.Set;+import java.util.regex.Pattern;/*** Catalog of AWS regions the emulator advertises. Single source of truth for@@ -54,6 +55,76 @@ public final class AwsRegions {return label != null && KNOWN_IDS.contains(label.toLowerCase(Locale.ROOT));}+ /** The partition every region falls back to: the commercial one. */+ public static final String DEFAULT_PARTITION = "aws";++ /** The DNS suffix of the commercial partition, shared with {@code aws-us-gov}. */+ public static final String DEFAULT_DNS_SUFFIX = "amazonaws.com";++ private record PartitionRule(Pattern regionPattern, String partition, String dnsSuffix) {+ }++ /**+ * Region-to-partition rules, transcribed from the AWS SDKs' own public partition metadata+ * (botocore's {@code partitions.json}, MIT-licensed and openly published at+ * https://github.com/boto/botocore/blob/develop/botocore/data/partitions.json). The patterns+ * are that file's {@code regionRegex} values verbatim, so they stay comparable against it.+ *+ * <p>Only the non-commercial partitions need a rule: the commercial {@code aws} partition is+ * the fallback, and {@code aws-us-gov} shares its DNS suffix, which is why GovCloud carries a+ * rule for the partition id alone. The rules are mutually exclusive by construction (nothing+ * matching {@code us-gov-*}, {@code us-iso-*} or {@code us-isob-*} matches the commercial+ * shape, because {@code \w} does not cross a hyphen), so evaluation order is not load-bearing.+ *+ * <p>An unrecognised region resolves to {@code aws}. That is what the SDKs themselves do, and+ * it keeps a region AWS launches tomorrow working rather than failing closed.+ */+ private static final List<PartitionRule> PARTITION_RULES = List.of(+ new PartitionRule(Pattern.compile("^cn-\\w+-\\d+$"), "aws-cn", "amazonaws.com.cn"),+ new PartitionRule(Pattern.compile("^us-gov-\\w+-\\d+$"), "aws-us-gov", DEFAULT_DNS_SUFFIX),+ new PartitionRule(Pattern.compile("^us-iso-\\w+-\\d+$"), "aws-iso", "c2s.ic.gov"),+ new PartitionRule(Pattern.compile("^us-isob-\\w+-\\d+$"), "aws-iso-b", "sc2s.sgov.gov"),+ new PartitionRule(Pattern.compile("^eu-isoe-\\w+-\\d+$"), "aws-iso-e", "cloud.adc-e.uk"),+ new PartitionRule(Pattern.compile("^us-isof-\\w+-\\d+$"), "aws-iso-f", "csp.hci.ic.gov"),+ new PartitionRule(Pattern.compile("^eusc-de-\\w+-\\d+$"), "aws-eusc", "amazonaws.eu"));++ /**+ * The partition id a region belongs to: {@code aws}, {@code aws-us-gov}, {@code aws-cn}, or+ * one of the classified partitions. This is the second segment of every ARN minted for a+ * resource in that region.+ *+ * <p>A null, blank or unrecognised region gives {@code aws}. Blank is not an error case: many+ * ARNs are global and carry no region at all ({@code arn:aws:iam::…}), and those keep the+ * commercial partition because the resource's own region cannot say otherwise.+ */+ public static String partitionFor(String region) {+ PartitionRule rule = ruleFor(region);+ return rule == null ? DEFAULT_PARTITION : rule.partition();+ }++ /**+ * The DNS suffix endpoints in a region's partition are served under, e.g.+ * {@code amazonaws.com.cn} for {@code cn-north-1}. Same fallback rule as+ * {@link #partitionFor}.+ */+ public static String dnsSuffixFor(String region) {+ PartitionRule rule = ruleFor(region);+ return rule == null ? DEFAULT_DNS_SUFFIX : rule.dnsSuffix();+ }++ private static PartitionRule ruleFor(String region) {+ if (region == null || region.isBlank()) {+ return null;+ }+ String normalized = region.trim().toLowerCase(Locale.ROOT);+ for (PartitionRule rule : PARTITION_RULES) {+ if (rule.regionPattern().matcher(normalized).matches()) {+ return rule;+ }+ }+ return null;+ }+private AwsRegions() {}}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinter.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinter.javaindex 9354f46758..31b6f5678f 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinter.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/kubernetes/EksTokenMinter.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.lambda.launcher.kubernetes;import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.core.common.AwsRegions;import javax.crypto.Mac;import javax.crypto.spec.SecretKeySpec;@@ -305,41 +306,13 @@ final class EksTokenMinter {record AwsCredentials(String accessKeyId, String secretAccessKey, String sessionToken) {}- /** Maps a region to its STS hostname, honoring the region's actual partition. */- private static String stsHost(String region) {- return "sts." + region + "." + partitionDnsSuffix(region);- }-/**- * Sourced from the AWS SDKs' own public partition metadata (e.g. botocore's- * {@code partitions.json}, MIT-licensed and openly published at- * https://github.com/boto/botocore/blob/develop/botocore/data/partitions.json), rather than- * assumed. Covers every partition that metadata currently defines: the commercial- * {@code aws} partition and {@code aws-us-gov} share {@code amazonaws.com} so neither needs- * a case of its own, {@code aws-cn} is the one commonly-hit split, and the classified- * ISO/ISOB/ISOE/ISOF partitions (regions matching {@code us-iso-*}, {@code us-isob-*},- * {@code eu-isoe-*}, {@code us-isof-*}) each resolve under their own distinct domain.+ * Maps a region to its STS hostname, honoring the region's actual partition. The partition+ * table lives in {@link AwsRegions}, shared with ARN construction, so a region added in one+ * place cannot be missing from the other.*/- private static String partitionDnsSuffix(String region) {- if (region.matches("cn-\\w+-\\d+")) {- return "amazonaws.com.cn";- }- if (region.matches("us-iso-\\w+-\\d+")) {- return "c2s.ic.gov";- }- if (region.matches("us-isob-\\w+-\\d+")) {- return "sc2s.sgov.gov";- }- if (region.matches("eu-isoe-\\w+-\\d+")) {- return "cloud.adc-e.uk";- }- if (region.matches("us-isof-\\w+-\\d+")) {- return "csp.hci.ic.gov";- }- if (region.matches("eusc-de-\\w+-\\d+")) {- return "amazonaws.eu";- }- return "amazonaws.com";+ private static String stsHost(String region) {+ return "sts." + region + "." + AwsRegions.dnsSuffixFor(region);}/**diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsArnUtilsTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsArnUtilsTest.javanew file mode 100644index 0000000000..149a9ae494--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsArnUtilsTest.java@@ -0,0 +1,170 @@+package io.github.hectorvent.floci.core.common;++import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;++/**+ * {@link AwsArnUtils} is the emulator's shared ARN helper and had no test of its own, despite+ * routing the whole cross-service tagging API through {@code TagDispatcher}. These pin the+ * parsing contract the callers depend on, most of it in the resource field: the helper splits+ * six segments and deliberately hands the resource back whole, because its structure is+ * service-specific.+ */+class AwsArnUtilsTest {++ @Test+ void parsesTheSixSegments() {+ AwsArnUtils.Arn arn = AwsArnUtils.parse("arn:aws:sqs:us-east-1:000000000000:my-queue");++ assertEquals("aws", arn.partition());+ assertEquals("sqs", arn.service());+ assertEquals("us-east-1", arn.region());+ assertEquals("000000000000", arn.accountId());+ assertEquals("my-queue", arn.resource());+ }++ /**+ * The resource keeps its own colons. {@code split(":", 6)} is what makes a Lambda qualified+ * ARN survive; a plain {@code split(":")} would strip the alias off the end.+ */+ @Test+ void resourceKeepsItsOwnColons() {+ AwsArnUtils.Arn arn = AwsArnUtils.parse(+ "arn:aws:lambda:us-east-1:000000000000:function:order-processor:PROD");++ assertEquals("function:order-processor:PROD", arn.resource());+ }++ /** Global services omit region and account, and those arrive as empty strings, never null. */+ @Test+ void omittedRegionAndAccountAreEmptyNotNull() {+ AwsArnUtils.Arn arn = AwsArnUtils.parse("arn:aws:s3:::my-bucket");++ assertEquals("", arn.region());+ assertEquals("", arn.accountId());+ assertEquals("my-bucket", arn.resource());+ }++ /** An empty resource is legal input and must not collapse the segment count. */+ @Test+ void emptyResourceStillParses() {+ AwsArnUtils.Arn arn = AwsArnUtils.parse("arn:aws:glue:us-east-1:000000000000:");++ assertEquals("glue", arn.service());+ assertEquals("", arn.resource());+ }++ @Test+ void parseIsTheInverseOfToString() {+ String text = "arn:aws:iam::000000000000:role/service-role/my-role";++ assertEquals(text, AwsArnUtils.parse(text).toString());+ }++ @ParameterizedTest+ @ValueSource(strings = {+ "arn:aws:sqs:us-east-1:000000000000",+ "arn:aws:sqs",+ "my-queue",+ "urn:aws:sqs:us-east-1:000000000000:my-queue",+ " "})+ void malformedArnsAreRejected(String value) {+ assertThrows(IllegalArgumentException.class, () -> AwsArnUtils.parse(value));+ }++ @Test+ void nullIsRejected() {+ assertThrows(IllegalArgumentException.class, () -> AwsArnUtils.parse(null));+ }++ /**+ * Non-commercial partitions parse like any other. Only construction pinned the partition,+ * never parsing.+ */+ @ParameterizedTest+ @CsvSource({+ "arn:aws-us-gov:kms:us-gov-west-1:000000000000:key/abc, aws-us-gov, us-gov-west-1",+ "arn:aws-cn:s3:cn-north-1:000000000000:bucket, aws-cn, cn-north-1",+ "arn:aws-iso:sns:us-iso-east-1:000000000000:topic, aws-iso, us-iso-east-1"})+ void foreignPartitionsParse(String text, String partition, String region) {+ AwsArnUtils.Arn arn = AwsArnUtils.parse(text);++ assertEquals(partition, arn.partition());+ assertEquals(region, arn.region());+ }++ @Test+ void regionOrDefaultFallsBackOnEveryFailureMode() {+ assertEquals("us-east-1", AwsArnUtils.regionOrDefault(null, "us-east-1"));+ assertEquals("us-east-1", AwsArnUtils.regionOrDefault("not-an-arn", "us-east-1"));+ assertEquals("us-east-1", AwsArnUtils.regionOrDefault("arn:aws:s3:::bucket", "us-east-1"));+ assertEquals("eu-west-1",+ AwsArnUtils.regionOrDefault("arn:aws:sqs:eu-west-1:000000000000:q", "us-east-1"));+ }++ @Test+ void accountOrDefaultFallsBackOnEveryFailureMode() {+ assertEquals("000000000000", AwsArnUtils.accountOrDefault(null, "000000000000"));+ assertEquals("000000000000", AwsArnUtils.accountOrDefault("not-an-arn", "000000000000"));+ assertEquals("000000000000",+ AwsArnUtils.accountOrDefault("arn:aws:s3:::bucket", "000000000000"));+ assertEquals("123456789012",+ AwsArnUtils.accountOrDefault("arn:aws:sqs:eu-west-1:123456789012:q", "000000000000"));+ }++ /**+ * The partition is derived from the region, so a resource in GovCloud or China is named with+ * the partition it actually lives in rather than always {@code aws}.+ */+ @ParameterizedTest+ @CsvSource({+ "us-east-1, arn:aws:sqs:us-east-1:000000000000:q",+ "eu-west-1, arn:aws:sqs:eu-west-1:000000000000:q",+ "us-gov-west-1, arn:aws-us-gov:sqs:us-gov-west-1:000000000000:q",+ "cn-north-1, arn:aws-cn:sqs:cn-north-1:000000000000:q",+ "us-iso-east-1, arn:aws-iso:sqs:us-iso-east-1:000000000000:q",+ "us-isob-east-1, arn:aws-iso-b:sqs:us-isob-east-1:000000000000:q",+ "eu-isoe-west-1, arn:aws-iso-e:sqs:eu-isoe-west-1:000000000000:q",+ "us-isof-south-1,arn:aws-iso-f:sqs:us-isof-south-1:000000000000:q",+ "eusc-de-east-1, arn:aws-eusc:sqs:eusc-de-east-1:000000000000:q"})+ void partitionIsDerivedFromTheRegion(String region, String expected) {+ assertEquals(expected, AwsArnUtils.Arn.of("sqs", region, "000000000000", "q").toString());+ }++ /**+ * Global services pass no region, and they keep the commercial partition. Thirty call sites+ * do this; anything else would rewrite every IAM, S3 and CloudFront ARN the emulator mints.+ */+ @Test+ void aRegionlessArnStaysInTheCommercialPartition() {+ assertEquals("arn:aws:iam::000000000000:role/r",+ AwsArnUtils.Arn.of("iam", "", "000000000000", "role/r").toString());+ }++ /** A region AWS has not launched yet must not fail closed. */+ @Test+ void anUnrecognisedRegionFallsBackToTheCommercialPartition() {+ assertEquals("arn:aws:sqs:xx-nowhere-9:000000000000:q",+ AwsArnUtils.Arn.of("sqs", "xx-nowhere-9", "000000000000", "q").toString());+ }++ /** The record constructor still takes an explicit partition, for echoing a caller's own. */+ @Test+ void theRecordConstructorKeepsAnExplicitPartition() {+ assertEquals("arn:aws-cn:secretsmanager:us-east-1:000000000000:secret:s",+ new AwsArnUtils.Arn("aws-cn", "secretsmanager", "us-east-1", "000000000000",+ "secret:s").toString());+ }++ @Test+ void queueUrlIsAccountThenQueueName() {+ assertEquals("http://localhost:4566/000000000000/my-queue",+ AwsArnUtils.arnToQueueUrl("arn:aws:sqs:us-east-1:000000000000:my-queue",+ "http://localhost:4566"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsRegionsTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsRegionsTest.javaindex 5a55f07fab..147e6bb70c 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/AwsRegionsTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsRegionsTest.java@@ -2,8 +2,11 @@ package io.github.hectorvent.floci.core.common;import org.junit.jupiter.api.Test;import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.NullAndEmptySource;import org.junit.jupiter.params.provider.ValueSource;+import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertTrue;@@ -44,4 +47,67 @@ class AwsRegionsTest {void nullIsNotARegionId() {assertFalse(AwsRegions.isRegionId(null));}++ /**+ * One row per partition botocore defines, so a partition going missing is a failing test+ * rather than a silently commercial ARN.+ */+ @ParameterizedTest+ @CsvSource({+ "us-east-1, aws, amazonaws.com",+ "eu-west-1, aws, amazonaws.com",+ "us-gov-west-1, aws-us-gov, amazonaws.com",+ "us-gov-east-1, aws-us-gov, amazonaws.com",+ "cn-north-1, aws-cn, amazonaws.com.cn",+ "cn-northwest-1, aws-cn, amazonaws.com.cn",+ "us-iso-east-1, aws-iso, c2s.ic.gov",+ "us-isob-east-1, aws-iso-b, sc2s.sgov.gov",+ "eu-isoe-west-1, aws-iso-e, cloud.adc-e.uk",+ "us-isof-south-1, aws-iso-f, csp.hci.ic.gov",+ "eusc-de-east-1, aws-eusc, amazonaws.eu"})+ void everyPartitionResolvesFromItsRegion(String region, String partition, String dnsSuffix) {+ assertEquals(partition, AwsRegions.partitionFor(region));+ assertEquals(dnsSuffix, AwsRegions.dnsSuffixFor(region));+ }++ /**+ * The pair that would collide under a naive prefix check: {@code us-isob-east-1} is+ * {@code aws-iso-b}, not {@code aws-iso}.+ */+ @Test+ void isobIsNotIso() {+ assertEquals("aws-iso", AwsRegions.partitionFor("us-iso-west-1"));+ assertEquals("aws-iso-b", AwsRegions.partitionFor("us-isob-west-1"));+ }++ /**+ * Blank is the common case, not an error: a global-service ARN carries no region and keeps+ * the commercial partition.+ */+ @ParameterizedTest+ @NullAndEmptySource+ @ValueSource(strings = {" ", "xx-nowhere-9", "not-a-region", "us-gov", "cn-north"})+ void blankAndUnrecognisedRegionsFallBackToCommercial(String region) {+ assertEquals("aws", AwsRegions.partitionFor(region));+ assertEquals("amazonaws.com", AwsRegions.dnsSuffixFor(region));+ }++ @Test+ void regionMatchingIsCaseInsensitive() {+ assertEquals("aws-cn", AwsRegions.partitionFor("CN-NORTH-1"));+ }++ /** Every GovCloud and China id the emulator recognises must land outside {@code aws}. */+ @Test+ void knownNonCommercialIdsAreNotCommercial() {+ for (String region : AwsRegions.KNOWN_IDS) {+ if (region.startsWith("us-gov-")) {+ assertEquals("aws-us-gov", AwsRegions.partitionFor(region), region);+ } else if (region.startsWith("cn-")) {+ assertEquals("aws-cn", AwsRegions.partitionFor(region), region);+ } else {+ assertEquals("aws", AwsRegions.partitionFor(region), region);+ }+ }+ }}