Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
new file mode 100644
index 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.md
index 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::Lam
provisions 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 Queues
An asynchronous invocation (`InvocationType: Event`) answers `202` immediately and runs on the background
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.java
index 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.java
new file mode 100644
index 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";
+ }
+}