Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): return current reserved concurrency in GetFunction (#4592)
Aniket Shukla071a170ce93e
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaGetFunctionConcurrencyTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaGetFunctionConcurrencyTest.javanew file mode 100644index 0000000000..bd10f58db0--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaGetFunctionConcurrencyTest.java@@ -0,0 +1,96 @@+package com.floci.test;++import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.core.SdkBytes;+import software.amazon.awssdk.services.lambda.LambdaClient;+import software.amazon.awssdk.services.lambda.model.FunctionCode;+import software.amazon.awssdk.services.lambda.model.GetFunctionResponse;+import software.amazon.awssdk.services.lambda.model.Runtime;++import static org.assertj.core.api.Assertions.assertThat;++@DisplayName("Lambda - GetFunction reserved concurrency")+class LambdaGetFunctionConcurrencyTest {++ private LambdaClient lambda;+ private String functionName;++ @BeforeEach+ void setup() {+ lambda = TestFixtures.lambdaClient();+ functionName = TestFixtures.uniqueName("sdk-get-concurrency");+ lambda.createFunction(request -> request.functionName(functionName)+ .runtime(Runtime.NODEJS20_X)+ .role("arn:aws:iam::000000000000:role/lambda-role")+ .handler("index.handler")+ .code(FunctionCode.builder().zipFile(SdkBytes.fromByteArray(LambdaUtils.minimalZip())).build()));+ }++ @AfterEach+ void cleanup() {+ try {+ lambda.deleteFunction(request -> request.functionName(functionName));+ } finally {+ lambda.close();+ }+ }++ @Test+ void getFunctionRoundTripsReservationUpdatesZeroAndDeletion() {+ assertThat(lambda.getFunction(request -> request.functionName(functionName)).concurrency()).isNull();++ for (int reservation : new int[]{2, 7, 0}) {+ lambda.putFunctionConcurrency(request -> request.functionName(functionName)+ .reservedConcurrentExecutions(reservation));+ GetFunctionResponse response = lambda.getFunction(request -> request.functionName(functionName));+ assertThat(response.concurrency()).isNotNull();+ assertThat(response.concurrency().reservedConcurrentExecutions()).isEqualTo(reservation);+ assertThat(response.configuration().functionName()).isEqualTo(functionName);+ assertThat(response.code().location()).isNotBlank();+ }++ lambda.deleteFunctionConcurrency(request -> request.functionName(functionName));+ assertThat(lambda.getFunction(request -> request.functionName(functionName)).concurrency()).isNull();+ }++ @Test+ void versionsAliasesAndQualifiedArnsOmitConcurrency() {+ lambda.putFunctionConcurrency(request -> request.functionName(functionName).reservedConcurrentExecutions(2));+ String version = lambda.publishVersion(request -> request.functionName(functionName)).version();+ lambda.createAlias(request -> request.functionName(functionName).name("live").functionVersion(version));+ String functionArn = lambda.getFunction(request -> request.functionName(functionName))+ .configuration().functionArn();++ for (int reservation : new int[]{7, 0}) {+ lambda.putFunctionConcurrency(request -> request.functionName(functionName)+ .reservedConcurrentExecutions(reservation));+ assertThat(lambda.getFunction(request -> request.functionName(functionName))+ .concurrency().reservedConcurrentExecutions()).isEqualTo(reservation);+ assertThat(lambda.getFunction(request -> request.functionName(functionArn))+ .concurrency().reservedConcurrentExecutions()).isEqualTo(reservation);+ assertThat(lambda.getFunctionConcurrency(request -> request.functionName(functionName))+ .reservedConcurrentExecutions()).isEqualTo(reservation);+ for (String qualifier : new String[]{"$LATEST", version, "live"}) {+ GetFunctionResponse response = lambda.getFunction(request -> request.functionName(functionName)+ .qualifier(qualifier));+ assertThat(response.configuration().version())+ .isEqualTo("$LATEST".equals(qualifier) ? "$LATEST" : version);+ assertThat(response.concurrency()).isNull();+ for (String reference : new String[]{functionName + ":" + qualifier, functionArn + ":" + qualifier}) {+ GetFunctionResponse byReference = lambda.getFunction(request -> request.functionName(reference));+ assertThat(byReference.concurrency()).isNull();+ assertThat(byReference.configuration().version()).isEqualTo(response.configuration().version());+ }+ }+ }++ lambda.deleteFunctionConcurrency(request -> request.functionName(functionName));+ assertThat(lambda.getFunction(request -> request.functionName(functionName).qualifier(version))+ .concurrency()).isNull();+ assertThat(lambda.getFunction(request -> request.functionName(functionArn + ":live"))+ .concurrency()).isNull();+ }+}diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex 33a70eeb81..279c1d8800 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -60,6 +60,15 @@ The event invoke configuration is stored and returned as AWS does, and `AWS::Lamprovisions it from a stack. Asynchronous invocations apply its retry, event age, destination settings,and dead-letter queue configurations (`DeadLetterConfig`).+### Reserved Concurrency++Unqualified `GetFunction` reads include `Concurrency.ReservedConcurrentExecutions` when a reservation+is set, including an explicit zero. Qualified reads omit `Concurrency`, whether `$LATEST`, a published+version, or an alias is supplied through `Qualifier` or embedded in the function name or ARN.+Use `GetFunctionConcurrency` to read the function-wide reservation separately.+Deleting the reservation with `DeleteFunctionConcurrency` removes the `Concurrency` member from+subsequent unqualified `GetFunction` responses.+### Asynchronous Invocation Retries and Dead-Letter QueuesAn asynchronous invocation (`InvocationType: Event`) answers `202` immediately and runs on the backgrounddiff --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 58d2326883..366afa6973 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@@ -123,6 +123,12 @@ public class LambdaController {tags.forEach(tagsNode::put);}+ Integer reservedConcurrency = fn.getReservedConcurrentExecutions();+ String effectiveQualifier = LambdaArnUtils.resolveWithQualifier(functionName, qualifier).qualifier();+ if (effectiveQualifier == null && reservedConcurrency != null) {+ root.putObject("Concurrency").put("ReservedConcurrentExecutions", reservedConcurrency);+ }+return Response.ok(root).build();}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaGetFunctionConcurrencyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaGetFunctionConcurrencyIntegrationTest.javanew file mode 100644index 0000000000..833e2f6fdc--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaGetFunctionConcurrencyIntegrationTest.java@@ -0,0 +1,177 @@+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.nio.charset.StandardCharsets;+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;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.not;++@QuarkusTest+class LambdaGetFunctionConcurrencyIntegrationTest {++ private static final String ACCOUNT = "000000004576";+ private static final String OTHER_ACCOUNT = "000000004577";+ private static final String REGION = "us-east-1";+ private static final String FUNCTIONS = "/2015-03-31/functions/";++ @Test+ void getFunctionReturnsCurrentReservationIncludingZeroAndOmitsItAfterDeletion() throws Exception {+ String name = createFunction(ACCOUNT, REGION);+ try {+ assertConcurrency(ACCOUNT, REGION, name, null, null);+ for (int reservation : new int[]{2, 7, 0}) {+ putConcurrency(ACCOUNT, REGION, name, reservation);+ assertConcurrency(ACCOUNT, REGION, name, null, reservation);+ }+ deleteConcurrency(ACCOUNT, REGION, name);+ assertConcurrency(ACCOUNT, REGION, name, null, null);+ given().header("Authorization", auth(ACCOUNT, REGION))+ .when().get(FUNCTIONS + name + "/configuration")+ .then().statusCode(200).body("$", not(hasKey("Concurrency")));+ } finally {+ deleteFunction(ACCOUNT, REGION, name);+ }+ }++ @Test+ void qualifiedReadsOmitConcurrencyEvenWhenAReservationIsSet() throws Exception {+ String name = createFunction(ACCOUNT, REGION);+ try {+ putConcurrency(ACCOUNT, REGION, name, 2);+ publishVersion(ACCOUNT, name);+ given().header("Authorization", auth(ACCOUNT, REGION)).contentType("application/json")+ .body("{\"Name\":\"live\",\"FunctionVersion\":\"1\"}")+ .when().post(FUNCTIONS + name + "/aliases").then().statusCode(201);+ String arn = "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:" + name;++ for (int reservation : new int[]{7, 0}) {+ putConcurrency(ACCOUNT, REGION, name, reservation);+ assertConcurrency(ACCOUNT, REGION, name, null, reservation);+ assertConcurrency(ACCOUNT, REGION, arn, null, reservation);+ for (String qualifier : new String[]{"$LATEST", "1", "live"}) {+ assertConcurrency(ACCOUNT, REGION, name, qualifier, null);+ assertConcurrency(ACCOUNT, REGION, name + ":" + qualifier, null, null);+ assertConcurrency(ACCOUNT, REGION, ACCOUNT + ":function:" + name + ":" + qualifier,+ null, null);+ assertConcurrency(ACCOUNT, REGION, arn, qualifier, null);+ assertConcurrency(ACCOUNT, REGION, arn + ":" + qualifier, null, null);+ assertConcurrency(ACCOUNT, REGION, arn + ":" + qualifier, qualifier, null);+ }+ }+ deleteConcurrency(ACCOUNT, REGION, name);+ assertConcurrency(ACCOUNT, REGION, name, "1", null);+ assertConcurrency(ACCOUNT, REGION, name, "live", null);+ } finally {+ deleteFunction(ACCOUNT, REGION, name);+ }+ }++ @Test+ void accountsHaveIndependentReservationsAndQualifiedArnsOmitConcurrency() throws Exception {+ String name = createFunction(ACCOUNT, REGION);+ createFunction(OTHER_ACCOUNT, REGION, name);+ try {+ putConcurrency(ACCOUNT, REGION, name, 2);+ putConcurrency(OTHER_ACCOUNT, REGION, name, 9);+ publishVersion(OTHER_ACCOUNT, name);+ putConcurrency(OTHER_ACCOUNT, REGION, name, 11);++ String arn = "arn:aws:lambda:" + REGION + ":" + OTHER_ACCOUNT + ":function:" + name;+ assertConcurrency(ACCOUNT, REGION, name, null, 2);+ assertConcurrency(OTHER_ACCOUNT, REGION, name, null, 11);+ assertConcurrency(OTHER_ACCOUNT, REGION, name, "1", null);+ assertConcurrency(ACCOUNT, REGION, arn + ":1", null, null);+ assertConcurrency(ACCOUNT, REGION, arn, "1", null);+ } finally {+ deleteFunction(ACCOUNT, REGION, name);+ deleteFunction(OTHER_ACCOUNT, REGION, name);+ }+ }++ @Test+ void reservationIsRegionScoped() throws Exception {+ String otherRegion = "eu-west-1";+ String name = createFunction(ACCOUNT, REGION);+ createFunction(ACCOUNT, otherRegion, name);+ try {+ putConcurrency(ACCOUNT, REGION, name, 2);+ putConcurrency(ACCOUNT, otherRegion, name, 9);+ assertConcurrency(ACCOUNT, REGION, name, null, 2);+ assertConcurrency(ACCOUNT, otherRegion, name, null, 9);+ } finally {+ deleteFunction(ACCOUNT, REGION, name);+ deleteFunction(ACCOUNT, otherRegion, name);+ }+ }++ private static String createFunction(String account, String region) throws Exception {+ String name = "get-concurrency-" + Long.toString(System.nanoTime(), 36);+ createFunction(account, region, name);+ return name;+ }++ private static void createFunction(String account, String region, String name) throws Exception {+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();+ try (ZipOutputStream zip = new ZipOutputStream(bytes)) {+ zip.putNextEntry(new ZipEntry("index.js"));+ zip.write("exports.handler = async () => ({});".getBytes(StandardCharsets.UTF_8));+ zip.closeEntry();+ }+ given().header("Authorization", auth(account, region)).contentType("application/json")+ .body("""+ {"FunctionName":"%s","Runtime":"nodejs20.x",+ "Role":"arn:aws:iam::%s:role/lambda-role","Handler":"index.handler",+ "Code":{"ZipFile":"%s"}}+ """.formatted(name, account, Base64.getEncoder().encodeToString(bytes.toByteArray())))+ .when().post(FUNCTIONS).then().statusCode(201);+ }++ private static void publishVersion(String account, String name) {+ given().header("Authorization", auth(account, REGION)).contentType("application/json").body("{}")+ .when().post(FUNCTIONS + name + "/versions")+ .then().statusCode(201).body("Version", equalTo("1"));+ }++ private static void putConcurrency(String account, String region, String name, int reservation) {+ given().header("Authorization", auth(account, region)).contentType("application/json")+ .body("{\"ReservedConcurrentExecutions\":" + reservation + "}")+ .when().put("/2017-10-31/functions/" + name + "/concurrency")+ .then().statusCode(200).body("ReservedConcurrentExecutions", equalTo(reservation));+ }++ private static void assertConcurrency(String account, String region, String name,+ String qualifier, Integer expected) {+ String path = FUNCTIONS + name + (qualifier == null ? "" : "?Qualifier=" + qualifier);+ if (expected == null) {+ given().header("Authorization", auth(account, region)).when().get(path)+ .then().statusCode(200).body("$", not(hasKey("Concurrency")));+ } else {+ given().header("Authorization", auth(account, region)).when().get(path)+ .then().statusCode(200)+ .body("Concurrency.ReservedConcurrentExecutions", equalTo(expected));+ }+ }++ private static void deleteConcurrency(String account, String region, String name) {+ given().header("Authorization", auth(account, region))+ .when().delete("/2017-10-31/functions/" + name + "/concurrency")+ .then().statusCode(204);+ }++ private static void deleteFunction(String account, String region, String name) {+ given().header("Authorization", auth(account, region))+ .when().delete(FUNCTIONS + name).then().statusCode(204);+ }++ private static String auth(String account, String region) {+ return "AWS4-HMAC-SHA256 Credential=" + account + "/20260929/" + region + "/lambda/aws4_request";+ }+}