Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): honour Qualifier on GetFunction and GetFunctionConfiguration (#2932)
Davidcf628ba2b914
diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.javaindex d45c6f7359..f1fa679257 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaController.java@@ -88,9 +88,10 @@ public class LambdaController {@Path("/functions/{functionName}")public Response getFunction(@Context HttpHeaders headers,@Context UriInfo uriInfo,- @PathParam("functionName") String functionName) {+ @PathParam("functionName") String functionName,+ @QueryParam("Qualifier") String qualifier) {String region = regionResolver.resolveRegion(headers);- LambdaFunction fn = lambdaService.getFunction(region, functionName);+ LambdaFunction fn = lambdaService.getFunction(region, functionName, qualifier);ObjectNode root = objectMapper.createObjectNode();root.set("Configuration", objectMapper.valueToTree(buildFunctionConfiguration(fn)));@@ -145,9 +146,10 @@ public class LambdaController {@GET@Path("/functions/{functionName}/configuration")public Response getFunctionConfiguration(@Context HttpHeaders headers,- @PathParam("functionName") String functionName) {+ @PathParam("functionName") String functionName,+ @QueryParam("Qualifier") String qualifier) {String region = regionResolver.resolveRegion(headers);- LambdaFunction fn = lambdaService.getFunction(region, functionName);+ LambdaFunction fn = lambdaService.getFunction(region, functionName, qualifier);return Response.ok(buildFunctionConfiguration(fn)).build();}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.javaindex be820bb34e..b00dfd67c2 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java@@ -475,6 +475,50 @@ public class LambdaService implements ResourceProvider {"Function not found: " + functionName, 404));}+ /**+ * Reads a function, honouring a {@code Qualifier} that selects a published version or an alias.+ *+ * <p>The read paths used to ignore the qualifier entirely and answer with {@code $LATEST} for+ * everything, including versions that were never published (issue #2821). That defeats the+ * point of publishing: a caller pinning version 1 silently got whatever {@code $LATEST} held at+ * the time of the call, and a typo or a stale alias read back as a live function instead of+ * failing. Resolution is delegated to the same target resolver the invoke path uses, so a+ * qualifier means the same thing whether you read it or run it.+ *+ * <p>A qualifier may also be carried on the name itself, as {@code fn:1} or a qualified ARN. An+ * explicit {@code Qualifier} and one embedded in the name must agree; AWS rejects the+ * combination when they do not.+ */+ public LambdaFunction getFunction(String region, String functionName, String qualifier) {+ LambdaArnUtils.ResolvedFunctionRef ref = LambdaArnUtils.resolve(functionName);+ enforceRegion(region, ref);+ String effective = resolveQualifier(ref.qualifier(), qualifier);+ if (effective == null) {+ return getFunction(region, functionName);+ }+ if (functionName.startsWith("arn:")) {+ AwsArnUtils.Arn arn = AwsArnUtils.parse(functionName);+ return resolveReadTargetForAccount(arn.accountId(), region, ref.name(), effective);+ }+ return resolveReadTarget(region, ref.name(), effective);+ }++ /**+ * Reconciles a qualifier carried on the function name with an explicit {@code Qualifier}+ * parameter. Either alone wins; both must agree.+ */+ private static String resolveQualifier(String onName, String explicit) {+ if (explicit == null || explicit.isBlank()) {+ return onName;+ }+ if (onName != null && !onName.equals(explicit)) {+ throw new AwsException("InvalidParameterValueException",+ "Cannot provide both a qualified function name and a Qualifier: "+ + onName + " and " + explicit, 400);+ }+ return explicit;+ }+/*** Resolves a {@code FunctionName} path parameter (bare name, partial ARN,* or full ARN, with optional {@code :qualifier}) to its canonical short@@ -895,6 +939,22 @@ public class LambdaService implements ResourceProvider {}private LambdaFunction resolveInvokeTarget(String region, String name, String qualifier) {+ return resolveTarget(region, name, qualifier, this::pickAliasVersion);+ }++ /**+ * Resolves a qualifier for a <em>read</em>. Identical to the invoke path except for aliases:+ * an alias with {@code AdditionalVersionWeights} shifts traffic, so {@link #pickAliasVersion}+ * chooses randomly among the weighted versions, which is right for running the function and+ * wrong for describing it. Two reads of one alias must not disagree, so a read follows the+ * alias's primary {@code FunctionVersion}, which is what AWS reports.+ */+ private LambdaFunction resolveReadTarget(String region, String name, String qualifier) {+ return resolveTarget(region, name, qualifier, LambdaAlias::getFunctionVersion);+ }++ private LambdaFunction resolveTarget(String region, String name, String qualifier,+ java.util.function.Function<LambdaAlias, String> aliasVersion) {if (qualifier == null || qualifier.equals("$LATEST")) {return functionStore.get(region, name).orElseThrow(() -> new AwsException("ResourceNotFoundException", "Function not found: " + name, 404));@@ -906,7 +966,7 @@ public class LambdaService implements ResourceProvider {}// qualifier is an alias nameLambdaAlias alias = getAlias(region, name, qualifier);- String version = pickAliasVersion(alias);+ String version = aliasVersion.apply(alias);if (version == null || version.equals("$LATEST")) {return functionStore.get(region, name).orElseThrow(() -> new AwsException("ResourceNotFoundException", "Function not found: " + name, 404));@@ -918,6 +978,18 @@ public class LambdaService implements ResourceProvider {private LambdaFunction resolveInvokeTargetForAccount(String accountId, String region, String name, String qualifier) {+ return resolveTargetForAccount(accountId, region, name, qualifier, this::pickAliasVersion);+ }++ /** The read counterpart of {@link #resolveInvokeTargetForAccount}; see {@link #resolveReadTarget}. */+ private LambdaFunction resolveReadTargetForAccount(+ String accountId, String region, String name, String qualifier) {+ return resolveTargetForAccount(accountId, region, name, qualifier, LambdaAlias::getFunctionVersion);+ }++ private LambdaFunction resolveTargetForAccount(+ String accountId, String region, String name, String qualifier,+ java.util.function.Function<LambdaAlias, String> aliasVersion) {if (qualifier == null || qualifier.equals("$LATEST")) {return functionStore.getForAccount(accountId, region, name).orElseThrow(() -> new AwsException("ResourceNotFoundException",@@ -936,7 +1008,7 @@ public class LambdaService implements ResourceProvider {if (alias == null) {throw new AwsException("ResourceNotFoundException", "Alias not found: " + qualifier, 404);}- String version = pickAliasVersion(alias);+ String version = aliasVersion.apply(alias);if (version == null || version.equals("$LATEST")) {return functionStore.getForAccount(accountId, region, name).orElseThrow(() -> new AwsException("ResourceNotFoundException",diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaQualifiedReadIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaQualifiedReadIntegrationTest.javanew file mode 100644index 0000000000..a9b5f9cb73--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaQualifiedReadIntegrationTest.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.lambda;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.Test;++import java.io.ByteArrayOutputStream;+import java.util.Base64;+import java.util.zip.ZipEntry;+import java.util.zip.ZipOutputStream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;++/**+ * Issue #2821: GetFunction and GetFunctionConfiguration ignored Qualifier and answered with+ * {@code $LATEST} for everything, including versions that were never published.+ *+ * <p>Two consequences, both measured against the live service by the reporter. A caller pinning a+ * published version silently got whatever {@code $LATEST} held at the time, which defeats the+ * immutability guarantee that is the point of publishing. And a read against a version that does+ * not exist succeeded instead of returning 404, so a typo or a stale alias looked live.+ */+@QuarkusTest+class LambdaQualifiedReadIntegrationTest {++ private static String zipB64(String body) throws Exception {+ ByteArrayOutputStream baos = new ByteArrayOutputStream();+ try (ZipOutputStream zos = new ZipOutputStream(baos)) {+ zos.putNextEntry(new ZipEntry("handler.py"));+ zos.write(("def handler(e, c):\n return {'body': '" + body + "'}\n").getBytes("UTF-8"));+ zos.closeEntry();+ }+ return Base64.getEncoder().encodeToString(baos.toByteArray());+ }++ private static String createFunction(String name, String body) throws Exception {+ given()+ .contentType("application/json")+ .body("""+ {"FunctionName": "%s", "Runtime": "python3.12",+ "Role": "arn:aws:iam::000000000000:role/r", "Handler": "handler.handler",+ "Code": {"ZipFile": "%s"}}+ """.formatted(name, zipB64(body)))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(anyOf200Or201());+ return name;+ }++ private static org.hamcrest.Matcher<Integer> anyOf200Or201() {+ return org.hamcrest.Matchers.anyOf(equalTo(200), equalTo(201));+ }++ @Test+ void aQualifierSelectsThePublishedVersionRatherThanLatest() throws Exception {+ String fn = "qual-read-" + Long.toString(System.nanoTime(), 36);+ createFunction(fn, "v1");++ given().contentType("application/json").body("{}")+ .when().post("/2015-03-31/functions/" + fn + "/versions")+ .then().statusCode(201).body("Version", equalTo("1"));++ // $LATEST moves on past version 1.+ given()+ .contentType("application/json")+ .body("{\"ZipFile\": \"%s\"}".formatted(zipB64("v2")))+ .when()+ .put("/2015-03-31/functions/" + fn + "/code")+ .then()+ .statusCode(200);++ given().when().get("/2015-03-31/functions/" + fn + "?Qualifier=1")+ .then().statusCode(200).body("Configuration.Version", equalTo("1"));++ given().when().get("/2015-03-31/functions/" + fn + "/configuration?Qualifier=1")+ .then().statusCode(200).body("Version", equalTo("1"));++ // Unqualified and an explicit $LATEST both still mean $LATEST.+ given().when().get("/2015-03-31/functions/" + fn)+ .then().statusCode(200).body("Configuration.Version", equalTo("$LATEST"));+ given().when().get("/2015-03-31/functions/" + fn + "?Qualifier=$LATEST")+ .then().statusCode(200).body("Configuration.Version", equalTo("$LATEST"));+ }++ @Test+ void aQualifierThatDoesNotResolveIsNotFound() throws Exception {+ String fn = "qual-404-" + Long.toString(System.nanoTime(), 36);+ createFunction(fn, "v1");++ // A version number that was never published, and a name that is not an alias. Answering+ // 200 with $LATEST is what let a typo run the wrong code.+ given().when().get("/2015-03-31/functions/" + fn + "?Qualifier=99")+ .then().statusCode(404);+ given().when().get("/2015-03-31/functions/" + fn + "/configuration?Qualifier=99")+ .then().statusCode(404);+ given().when().get("/2015-03-31/functions/" + fn + "?Qualifier=notaversion")+ .then().statusCode(404);+ }++ @Test+ void aQualifierMayBeCarriedOnTheNameAndMustAgreeWithAnExplicitOne() throws Exception {+ String fn = "qual-name-" + Long.toString(System.nanoTime(), 36);+ createFunction(fn, "v1");+ given().contentType("application/json").body("{}")+ .when().post("/2015-03-31/functions/" + fn + "/versions")+ .then().statusCode(201);++ given().when().get("/2015-03-31/functions/" + fn + ":1")+ .then().statusCode(200).body("Configuration.Version", equalTo("1"));++ // Agreeing is fine; disagreeing is a client error rather than a silent pick of one.+ given().when().get("/2015-03-31/functions/" + fn + ":1?Qualifier=1")+ .then().statusCode(200).body("Configuration.Version", equalTo("1"));+ given().when().get("/2015-03-31/functions/" + fn + ":1?Qualifier=2")+ .then().statusCode(400);+ }++ @Test+ void aWeightedAliasReadsDeterministicallyAsItsPrimaryVersion() throws Exception {+ // An alias with AdditionalVersionWeights shifts traffic, so the invoke path picks among the+ // weighted versions at random. That is right for running the function and wrong for+ // describing it: two reads of one alias must not disagree. AWS reports the alias's primary+ // FunctionVersion, so a 50/50 split must still read as version 1 every time.+ String fn = "qual-alias-" + Long.toString(System.nanoTime(), 36);+ createFunction(fn, "v1");+ given().contentType("application/json").body("{}")+ .when().post("/2015-03-31/functions/" + fn + "/versions")+ .then().statusCode(201).body("Version", equalTo("1"));++ given()+ .contentType("application/json")+ .body("{\"ZipFile\": \"%s\"}".formatted(zipB64("v2")))+ .when().put("/2015-03-31/functions/" + fn + "/code").then().statusCode(200);+ given().contentType("application/json").body("{\"Description\": \"second\"}")+ .when().post("/2015-03-31/functions/" + fn + "/versions")+ .then().statusCode(201).body("Version", equalTo("2"));++ given()+ .contentType("application/json")+ .body("""+ {"Name": "live", "FunctionVersion": "1",+ "RoutingConfig": {"AdditionalVersionWeights": {"2": 0.5}}}+ """)+ .when().post("/2015-03-31/functions/" + fn + "/aliases")+ .then().statusCode(org.hamcrest.Matchers.anyOf(equalTo(200), equalTo(201)));++ // Repeat enough that a random pick would almost certainly show version 2 at least once.+ for (int i = 0; i < 20; i++) {+ given().when().get("/2015-03-31/functions/" + fn + "?Qualifier=live")+ .then().statusCode(200).body("Configuration.Version", equalTo("1"));+ given().when().get("/2015-03-31/functions/" + fn + "/configuration?Qualifier=live")+ .then().statusCode(200).body("Version", equalTo("1"));+ }+ }+}