Light, fluffy, and always free - The AWS Local Emulator alternative
feat(lambda): store DurableConfig on functions (execution later) (#5007)
TATSUNO “Taz” Yasuhiro823f8751de0f
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.javaindex 10e6ea77d9..734660cc86 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaFunctionConfigTest.java@@ -275,4 +275,57 @@ class LambdaFunctionConfigTest {} catch (Exception ignored) {}}}++ @Test+ @Order(7)+ @DisplayName("DurableConfig round-trips via create, update and get")+ void durableConfigRoundTrips() {+ String durableFn = TestFixtures.uniqueName("fn-durable");+ try {+ CreateFunctionResponse createResp = lambda.createFunction(CreateFunctionRequest.builder()+ .functionName(durableFn)+ .runtime(Runtime.NODEJS20_X)+ .role(ROLE)+ .handler("index.handler")+ .code(FunctionCode.builder()+ .zipFile(SdkBytes.fromByteArray(LambdaUtils.minimalZip()))+ .build())+ .durableConfig(DurableConfig.builder().executionTimeout(3600).build())+ .build());++ assertThat(createResp.durableConfig().executionTimeout()).isEqualTo(3600);+ assertThat(createResp.durableConfig().retentionPeriodInDays())+ .as("RetentionPeriodInDays defaults to 14")+ .isEqualTo(14);+ assertThat(createResp.timeout())+ .as("Timeout of a durable function defaults to the 15 minute cap")+ .isEqualTo(900);++ UpdateFunctionConfigurationResponse updateResp = lambda.updateFunctionConfiguration(+ UpdateFunctionConfigurationRequest.builder()+ .functionName(durableFn)+ .durableConfig(DurableConfig.builder().retentionPeriodInDays(7).build())+ .build());+ assertThat(updateResp.durableConfig().executionTimeout())+ .as("a member left out of the update keeps its value")+ .isEqualTo(3600);+ assertThat(updateResp.durableConfig().retentionPeriodInDays()).isEqualTo(7);++ GetFunctionConfigurationResponse getResp = lambda.getFunctionConfiguration(+ GetFunctionConfigurationRequest.builder().functionName(durableFn).build());+ assertThat(getResp.durableConfig().retentionPeriodInDays()).isEqualTo(7);++ GetFunctionConfigurationResponse plain = lambda.getFunctionConfiguration(+ GetFunctionConfigurationRequest.builder().functionName(FN).build());+ assertThat(plain.durableConfig())+ .as("a function created without DurableConfig has none")+ .isNull();+ } finally {+ try {+ lambda.deleteFunction(DeleteFunctionRequest.builder().functionName(durableFn).build());+ } catch (Exception ignored) {+ // Cleanup only. A failed delete must not hide the test result.+ }+ }+ }}diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex 6e6dfb7141..b9993435b1 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -675,9 +675,9 @@ No extra configuration or `cap_add` is needed because Docker containers have`CAP_NET_BIND_SERVICE` in their default capability set, so Floci (running as anon-root user) can bind UDP/53 without any changes to your Compose file.-### VpcConfig, SnapStart and LoggingConfig+### VpcConfig, SnapStart, LoggingConfig and DurableConfig-All three round-trip through `CreateFunction`, `UpdateFunctionConfiguration`,+All four round-trip through `CreateFunction`, `UpdateFunctionConfiguration`,`GetFunctionConfiguration`, `GetFunction`, `ListFunctions` and `PublishVersion`.The response shapes are **not** the request shapes, and Floci follows the AWS model@@ -688,6 +688,7 @@ rather than echoing the request back:| `VpcConfig` | `VpcConfig` | `VpcConfigResponse` | `VpcId`, resolved from the first subnet via EC2 || `SnapStart` | `SnapStart` | `SnapStartResponse` | `OptimizationStatus` — `On` only for a published version with `ApplyOn=PublishedVersions`, `Off` for `$LATEST` || `LoggingConfig` | `LoggingConfig` | `LoggingConfig` | — |+| `DurableConfig` | `DurableConfig` | `DurableConfig` | `RetentionPeriodInDays` defaults to 14; omitted for a function created without it |`SnapStart` and `LoggingConfig` are always present in a response, as on AWS: anunset function reads back `SnapStart={ApplyOn: None, OptimizationStatus: Off}` and@@ -699,6 +700,12 @@ is a permanent diff rather than a cosmetic omission.`LoggingConfig` is replaced wholesale on update, not merged — an update naming only`LogFormat` resets `LogGroup` to the default.+`DurableConfig` requires `ExecutionTimeout` on create. A durable function created without+a `Timeout` gets `min(ExecutionTimeout, 900)`. It always logs in JSON format, and+`LogFormat: Text` is rejected. On update the members are merged, and a function created+without `DurableConfig` cannot gain one. The durable execution itself (checkpoints, waits,+callbacks) is not emulated yet; the configuration only round-trips.+`LogGroup` is validated against AWS's documented constraint: 1-512 characters matching`[.\-_/#A-Za-z0-9]+`. `ApplicationLogLevel` and `SystemLogLevel` are accepted with any`LogFormat` but are only ever stored — and therefore only ever returned — when thediff --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 67b20a2162..fc24eece71 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@@ -769,12 +769,26 @@ public class LambdaController {putSnapStart(node, fn);putLoggingConfig(node, fn);putRuntimeVersionConfig(node, fn);+ putDurableConfig(node, fn);@SuppressWarnings("unchecked")Map<String, Object> result = objectMapper.convertValue(node, Map.class);return result;}+ /** Only durable functions carry a DurableConfig; AWS omits the member for every other function. */+ private void putDurableConfig(ObjectNode node, LambdaFunction fn) {+ if (!fn.isDurable()) {+ return;+ }+ ObjectNode durable = node.putObject("DurableConfig");+ durable.put("ExecutionTimeout", fn.getDurableExecutionTimeout());+ durable.put("RetentionPeriodInDays", fn.getDurableRetentionPeriodInDays());+ if (fn.getDurableKmsKeyArn() != null) {+ durable.put("KMSKeyArn", fn.getDurableKmsKeyArn());+ }+ }+/*** VpcConfigResponse, not VpcConfig: the response shape adds VpcId, which the request shape* has no member for. Emitted only while the function is actually attached to a VPC — AWSdiff --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 e8b9de91bc..a7feb187f9 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@@ -89,6 +89,13 @@ public class LambdaService implements ResourceProvider {private static final int MAX_TAG_KEY_LENGTH = 128;private static final Pattern KMS_KEY_ARN_PATTERN = Pattern.compile("^(arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)?$");+ /** The DurableConfig member has its own pattern text, which AWS prints in the validation message. */+ private static final Pattern DURABLE_KMS_KEY_ARN_PATTERN = Pattern.compile(+ "(arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()");+ private static final int MAX_DURABLE_EXECUTION_TIMEOUT_SECONDS = 31622400;+ private static final int MAX_DURABLE_RETENTION_DAYS = 90;+ private static final int DEFAULT_DURABLE_RETENTION_DAYS = 14;+ private static final int MAX_FUNCTION_TIMEOUT_SECONDS = 900;private static final Pattern LAYER_VERSION_ARN_PATTERN = Pattern.compile("^((arn:(aws[a-zA-Z-]*)?:lambda:(eusc-)?[a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:\\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+)"+ "|(arn:[a-zA-Z0-9-]+:lambda:::awslayer:[a-zA-Z0-9-_]+))$");@@ -124,7 +131,7 @@ public class LambdaService implements ResourceProvider {*/private static final List<String> CONFIG_STRUCTURE_MEMBERS = List.of("Environment", "EphemeralStorage", "TracingConfig", "DeadLetterConfig",- "VpcConfig", "SnapStart", "LoggingConfig", "ImageConfig");+ "VpcConfig", "SnapStart", "LoggingConfig", "ImageConfig", "DurableConfig");private final LambdaFunctionStore functionStore;private final LambdaExecutorService executorService;@@ -404,6 +411,7 @@ public class LambdaService implements ResourceProvider {Map<String, Object> snapStart = structureMember(request, "SnapStart");Map<String, Object> loggingConfig = structureMember(request, "LoggingConfig");Map<String, Object> imageConfig = structureMember(request, "ImageConfig");+ Map<String, Object> durableConfig = structureMember(request, "DurableConfig");Map<String, Object> code = structureMember(request, "Code");String functionName = (String) request.get("FunctionName");@@ -413,7 +421,16 @@ public class LambdaService implements ResourceProvider {validateEnum(request.get("PackageType"), "packageType", List.of("Zip", "Image"));String packageType = request.getOrDefault("PackageType", "Zip").toString();String description = (String) request.get("Description");- int timeout = toInt(request.get("Timeout"), config != null ? config.services().lambda().defaultTimeoutSeconds() : 3);+ DurableConfigRequest durable = durableConfigRequest(durableConfig);+ int defaultTimeout = config != null ? config.services().lambda().defaultTimeoutSeconds() : 3;+ if (durable != null) {+ if (durable.executionTimeout() == null) {+ throw new AwsException("InvalidParameterValueException",+ "You cannot create a function with a durable configuration without an executionTimeout", 400);+ }+ defaultTimeout = Math.min(durable.executionTimeout(), MAX_FUNCTION_TIMEOUT_SECONDS);+ }+ int timeout = toInt(request.get("Timeout"), defaultTimeout);int memorySize = toInt(request.get("MemorySize"), config != null ? config.services().lambda().defaultMemoryMb() : 128);if (functionName == null || functionName.isBlank()) {@@ -511,6 +528,7 @@ public class LambdaService implements ResourceProvider {}applySnapStart(fn, snapStart);+ applyDurableConfig(fn, durable);applyLoggingConfig(fn, loggingConfig);List<LambdaFileSystemConfig> fileSystemConfigs =@@ -772,6 +790,7 @@ public class LambdaService implements ResourceProvider {Map<String, Object> snapStart = structureMember(request, "SnapStart");Map<String, Object> loggingConfig = structureMember(request, "LoggingConfig");Map<String, Object> imageConfig = structureMember(request, "ImageConfig");+ Map<String, Object> durableConfig = structureMember(request, "DurableConfig");// Validated before any field mutation below, not inline where Layers is applied further// down - fn is the live object backing this store entry (InMemoryStorage#get returns the@@ -798,8 +817,14 @@ public class LambdaService implements ResourceProvider {validateSnapStart(snapStart);}if (request.containsKey("LoggingConfig")) {- validateLoggingConfig(loggingConfig);+ validateLoggingConfig(loggingConfig, fn.isDurable());+ }+ if (durableConfig != null && !fn.isDurable()) {+ throw new AwsException("InvalidParameterValueException",+ "You cannot add a durable configuration to a function that was originally created "+ + "with no durable configuration", 400);}+ DurableConfigRequest durable = durableConfigRequest(durableConfig);if (request.containsKey("Role")) {validateRoleArn((String) request.get("Role"));}@@ -904,6 +929,10 @@ public class LambdaService implements ResourceProvider {applyLoggingConfig(fn, loggingConfig);}+ if (durable != null) {+ mergeDurableConfig(fn, durable);+ }+if (request.containsKey("FileSystemConfigs")) {fn.setFileSystemConfigs(requestedFileSystemConfigs);}@@ -2249,6 +2278,9 @@ public class LambdaService implements ResourceProvider {snapshot.setTracingMode(fn.getTracingMode());snapshot.setDeadLetterTargetArn(fn.getDeadLetterTargetArn());snapshot.setKmsKeyArn(fn.getKmsKeyArn());+ snapshot.setDurableExecutionTimeout(fn.getDurableExecutionTimeout());+ snapshot.setDurableRetentionPeriodInDays(fn.getDurableRetentionPeriodInDays());+ snapshot.setDurableKmsKeyArn(fn.getDurableKmsKeyArn());functionStore.save(region, snapshot);LOG.infov("Published version {0} for function {1}", version, functionName);@@ -2443,10 +2475,75 @@ public class LambdaService implements ResourceProvider {fn.setSnapStartApplyOn(applyOn instanceof String s && !s.isBlank() ? s : "None");}- private static void validateLoggingConfig(Object value) {+ /** The members of a request's DurableConfig after type, range and pattern validation; each may be absent. */+ private record DurableConfigRequest(Integer executionTimeout, Integer retentionPeriodInDays, String kmsKeyArn) {+ }++ private static DurableConfigRequest durableConfigRequest(Map<String, Object> durableConfig) {+ if (durableConfig == null) {+ return null;+ }+ Integer executionTimeout = durableConfigInteger(durableConfig.get("ExecutionTimeout"),+ "ExecutionTimeout", MAX_DURABLE_EXECUTION_TIMEOUT_SECONDS);+ Integer retentionPeriodInDays = durableConfigInteger(durableConfig.get("RetentionPeriodInDays"),+ "RetentionPeriodInDays", MAX_DURABLE_RETENTION_DAYS);+ Object kmsKeyArn = durableConfig.get("KMSKeyArn");+ if (kmsKeyArn != null && !(kmsKeyArn instanceof String)) {+ throw new AwsException("SerializationException", "DurableConfig.KMSKeyArn must be a string", 400);+ }+ validatePattern(kmsKeyArn, "durableConfig.kMSKeyArn", DURABLE_KMS_KEY_ARN_PATTERN);+ return new DurableConfigRequest(executionTimeout, retentionPeriodInDays, (String) kmsKeyArn);+ }++ private static Integer durableConfigInteger(Object value, String member, int maximum) {+ if (value == null) {+ return null;+ }+ if (!(value instanceof Byte || value instanceof Short || value instanceof Integer || value instanceof Long)) {+ throw new AwsException("SerializationException", "DurableConfig." + member + " must be an integer", 400);+ }+ long number = ((Number) value).longValue();+ if (number < 1 || number > maximum) {+ String field = "durableConfig." + Character.toLowerCase(member.charAt(0)) + member.substring(1);+ String bound = number < 1 ? "greater than or equal to 1" : "less than or equal to " + maximum;+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + number + "' at '" + field + "' failed to satisfy "+ + "constraint: Member must have value " + bound, 400);+ }+ return (int) number;+ }++ private static void applyDurableConfig(LambdaFunction fn, DurableConfigRequest durable) {+ if (durable == null) {+ return;+ }+ fn.setDurableRetentionPeriodInDays(DEFAULT_DURABLE_RETENTION_DAYS);+ mergeDurableConfig(fn, durable);+ fn.setLogFormat("JSON");+ }++ /** UpdateFunctionConfiguration merges DurableConfig per member; a member left out keeps its stored value. */+ private static void mergeDurableConfig(LambdaFunction fn, DurableConfigRequest durable) {+ if (durable.executionTimeout() != null) {+ fn.setDurableExecutionTimeout(durable.executionTimeout());+ }+ if (durable.retentionPeriodInDays() != null) {+ fn.setDurableRetentionPeriodInDays(durable.retentionPeriodInDays());+ }+ if (durable.kmsKeyArn() != null) {+ fn.setDurableKmsKeyArn(durable.kmsKeyArn().isEmpty() ? null : durable.kmsKeyArn());+ }+ }++ private static void validateLoggingConfig(Object value, boolean durable) {if (!(value instanceof Map<?, ?> logging)) {return;}+ if (durable && "Text".equals(logging.get("LogFormat"))) {+ throw new AwsException("InvalidParameterValueException",+ "You cannot use plain text logs with a durable function. Only JSON format logs are supported",+ 400);+ }validateEnum(logging.get("LogFormat"), "loggingConfig.logFormat", List.of("JSON", "Text"));validateEnum(logging.get("ApplicationLogLevel"), "loggingConfig.applicationLogLevel",List.of("TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"));@@ -2614,8 +2711,9 @@ public class LambdaService implements ResourceProvider {if (!(value instanceof Map<?, ?> logging)) {return;}- validateLoggingConfig(value);- String format = logging.get("LogFormat") instanceof String f && !f.isBlank() ? f : "Text";+ validateLoggingConfig(value, fn.isDurable());+ String defaultFormat = fn.isDurable() ? "JSON" : "Text";+ String format = logging.get("LogFormat") instanceof String f && !f.isBlank() ? f : defaultFormat;boolean json = "JSON".equals(format);fn.setLogFormat(format);fn.setApplicationLogLevel(json && logging.get("ApplicationLogLevel") instanceof String leveldiff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.java b/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.javaindex 28772a62cf..2c3df4150f 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/model/LambdaFunction.java@@ -69,6 +69,10 @@ public class LambdaFunction {private String logGroup;private List<LambdaFileSystemConfig> fileSystemConfigs = new ArrayList<>();private String codeSha256;+ /** Non-null only for durable functions: AWS requires ExecutionTimeout whenever DurableConfig is given. */+ private Integer durableExecutionTimeout;+ private Integer durableRetentionPeriodInDays;+ private String durableKmsKeyArn;/** Non-null only for hot-reload functions. Holds the Docker-host path bind-mounted into /var/task. */private String hotReloadHostPath;@@ -215,6 +219,22 @@ public class LambdaFunction {public String getCodeSha256() { return codeSha256; }public void setCodeSha256(String codeSha256) { this.codeSha256 = codeSha256; }+ public Integer getDurableExecutionTimeout() { return durableExecutionTimeout; }+ public void setDurableExecutionTimeout(Integer durableExecutionTimeout) {+ this.durableExecutionTimeout = durableExecutionTimeout;+ }++ public Integer getDurableRetentionPeriodInDays() { return durableRetentionPeriodInDays; }+ public void setDurableRetentionPeriodInDays(Integer durableRetentionPeriodInDays) {+ this.durableRetentionPeriodInDays = durableRetentionPeriodInDays;+ }++ public String getDurableKmsKeyArn() { return durableKmsKeyArn; }+ public void setDurableKmsKeyArn(String durableKmsKeyArn) { this.durableKmsKeyArn = durableKmsKeyArn; }++ @JsonIgnore+ public boolean isDurable() { return durableExecutionTimeout != null; }+public String getHotReloadHostPath() { return hotReloadHostPath; }public void setHotReloadHostPath(String hotReloadHostPath) { this.hotReloadHostPath = hotReloadHostPath; }diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaDurableConfigIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaDurableConfigIntegrationTest.javanew file mode 100644index 0000000000..a492e2d126--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaDurableConfigIntegrationTest.java@@ -0,0 +1,259 @@+package io.github.hectorvent.floci.services.lambda;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.not;++/**+ * DurableConfig marks a function as a durable function. It is accepted by CreateFunction and+ * UpdateFunctionConfiguration, snapshotted by PublishVersion, and returned by every read, while a+ * plain function never carries the member.+ */+@QuarkusTest+class LambdaDurableConfigIntegrationTest {++ private static final String BASE_PATH = "/2015-03-31";+ private static final String KMS_KEY_ARN =+ "arn:aws:kms:us-east-1:000000000000:key/11111111-1111-1111-1111-111111111111";+ private static final String TEXT_LOGS_MESSAGE = "You cannot use plain text logs with a durable function. "+ + "Only JSON format logs are supported";++ /** Posts CreateFunction for {@code name}; {@code members} are extra JSON members, already comma separated. */+ private static ValidatableResponse createFunction(String name, String members) {+ String body = """+ {+ "FunctionName": "%s",+ "Runtime": "nodejs20.x",+ "Role": "arn:aws:iam::000000000000:role/lambda-role",+ "Handler": "index.handler"%s+ }+ """.formatted(name, members.isEmpty() ? "" : ",\n" + members);+ return given()+ .contentType("application/json")+ .body(body)+ .when()+ .post(BASE_PATH + "/functions")+ .then();+ }++ private static ValidatableResponse createDurableFunction(String name, String durableConfig) {+ return createFunction(name, "\"DurableConfig\": " + durableConfig);+ }++ private static ValidatableResponse updateConfiguration(String name, String body) {+ return given()+ .contentType("application/json")+ .body(body)+ .when()+ .put(BASE_PATH + "/functions/" + name + "/configuration")+ .then();+ }++ private static ValidatableResponse getConfiguration(String name) {+ return getConfiguration(name, "");+ }++ private static ValidatableResponse getConfiguration(String name, String query) {+ return given()+ .when()+ .get(BASE_PATH + "/functions/" + name + "/configuration" + query)+ .then();+ }++ @Test+ void createDefaultsRetentionTimeoutAndJsonLogging() {+ createDurableFunction("durable-defaults-fn", "{\"ExecutionTimeout\": 3600}")+ .statusCode(201)+ .body("DurableConfig.ExecutionTimeout", equalTo(3600))+ .body("DurableConfig.RetentionPeriodInDays", equalTo(14))+ .body("DurableConfig", not(hasKey("KMSKeyArn")))+ .body("Timeout", equalTo(900))+ .body("LoggingConfig.LogFormat", equalTo("JSON"))+ .body("LoggingConfig.ApplicationLogLevel", equalTo("INFO"))+ .body("LoggingConfig.SystemLogLevel", equalTo("INFO"));++ createDurableFunction("durable-short-timeout-fn", "{\"ExecutionTimeout\": 60}")+ .statusCode(201)+ .body("Timeout", equalTo(60));+ }++ @Test+ void createKeepsExplicitMembers() {+ createFunction("durable-explicit-fn", """+ "Timeout": 3,+ "DurableConfig": {+ "ExecutionTimeout": 60,+ "RetentionPeriodInDays": 7,+ "KMSKeyArn": "%s"+ }""".formatted(KMS_KEY_ARN))+ .statusCode(201);++ getConfiguration("durable-explicit-fn")+ .statusCode(200)+ .body("Timeout", equalTo(3))+ .body("DurableConfig.ExecutionTimeout", equalTo(60))+ .body("DurableConfig.RetentionPeriodInDays", equalTo(7))+ .body("DurableConfig.KMSKeyArn", equalTo(KMS_KEY_ARN));+ }++ @Test+ void emptyKmsKeyArnMeansNoKey() {+ createDurableFunction("durable-no-key-fn", "{\"ExecutionTimeout\": 60, \"KMSKeyArn\": \"\"}")+ .statusCode(201)+ .body("DurableConfig", not(hasKey("KMSKeyArn")));+ }++ @Test+ void durableFunctionLogsInJsonFormatOnly() {+ createFunction("durable-text-logs-fn", """+ "LoggingConfig": {"LogFormat": "Text"},+ "DurableConfig": {"ExecutionTimeout": 60}""")+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", equalTo(TEXT_LOGS_MESSAGE));++ createFunction("durable-partial-logs-fn", """+ "LoggingConfig": {"LogGroup": "/custom/durable"},+ "DurableConfig": {"ExecutionTimeout": 60}""")+ .statusCode(201)+ .body("LoggingConfig.LogFormat", equalTo("JSON"))+ .body("LoggingConfig.LogGroup", equalTo("/custom/durable"));++ createFunction("durable-json-levels-fn", """+ "LoggingConfig": {"LogFormat": "JSON", "ApplicationLogLevel": "WARN"},+ "DurableConfig": {"ExecutionTimeout": 60}""")+ .statusCode(201)+ .body("LoggingConfig.ApplicationLogLevel", equalTo("WARN"))+ .body("LoggingConfig.SystemLogLevel", equalTo("INFO"));++ updateConfiguration("durable-partial-logs-fn", "{\"LoggingConfig\": {\"LogFormat\": \"Text\"}}")+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", equalTo(TEXT_LOGS_MESSAGE));++ updateConfiguration("durable-partial-logs-fn", "{\"LoggingConfig\": {\"LogGroup\": \"/custom/updated\"}}")+ .statusCode(200)+ .body("LoggingConfig.LogFormat", equalTo("JSON"))+ .body("LoggingConfig.LogGroup", equalTo("/custom/updated"));+ }++ @Test+ void plainFunctionHasNoDurableConfig() {+ createFunction("plain-no-durable-fn", "")+ .statusCode(201)+ .body("$", not(hasKey("DurableConfig")))+ .body("Timeout", equalTo(3))+ .body("LoggingConfig.LogFormat", equalTo("Text"));++ getConfiguration("plain-no-durable-fn")+ .statusCode(200)+ .body("$", not(hasKey("DurableConfig")));+ }++ @Test+ void createWithoutExecutionTimeoutIsRejected() {+ createDurableFunction("durable-invalid-fn", "{\"RetentionPeriodInDays\": 7}")+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", equalTo("You cannot create a function with a durable configuration "+ + "without an executionTimeout"));+ }++ @Test+ void membersOutOfRangeAreValidationErrors() {+ createDurableFunction("durable-invalid-fn", "{\"ExecutionTimeout\": 0}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("1 validation error detected: Value '0' at "+ + "'durableConfig.executionTimeout' failed to satisfy constraint: "+ + "Member must have value greater than or equal to 1"));++ createDurableFunction("durable-invalid-fn", "{\"ExecutionTimeout\": 60, \"RetentionPeriodInDays\": 91}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("1 validation error detected: Value '91' at "+ + "'durableConfig.retentionPeriodInDays' failed to satisfy constraint: "+ + "Member must have value less than or equal to 90"));+ }++ @Test+ void nonIntegerMembersAreSerializationErrors() {+ createDurableFunction("durable-invalid-fn", "{\"ExecutionTimeout\": \"60\"}")+ .statusCode(400)+ .body("__type", equalTo("SerializationException"))+ .body("message", equalTo("DurableConfig.ExecutionTimeout must be an integer"));+ }++ @Test+ void kmsKeyArnMustMatchThePattern() {+ createDurableFunction("durable-invalid-fn", "{\"ExecutionTimeout\": 60, \"KMSKeyArn\": \"not-an-arn\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("1 validation error detected: Value 'not-an-arn' at "+ + "'durableConfig.kMSKeyArn' failed to satisfy constraint: Member must satisfy regular "+ + "expression pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()"));+ }++ @Test+ void updateMergesMembersAndAPublishedVersionKeepsItsSnapshot() {+ createDurableFunction("durable-update-fn", "{\"ExecutionTimeout\": 3600, \"RetentionPeriodInDays\": 7}")+ .statusCode(201);++ given()+ .contentType("application/json")+ .body("{}")+ .when()+ .post(BASE_PATH + "/functions/durable-update-fn/versions")+ .then()+ .statusCode(201)+ .body("Version", equalTo("1"))+ .body("DurableConfig.ExecutionTimeout", equalTo(3600))+ .body("DurableConfig.RetentionPeriodInDays", equalTo(7));++ updateDurableConfig("durable-update-fn", "{\"ExecutionTimeout\": 7200}")+ .statusCode(200)+ .body("DurableConfig.ExecutionTimeout", equalTo(7200))+ .body("DurableConfig.RetentionPeriodInDays", equalTo(7));++ updateDurableConfig("durable-update-fn", "{\"RetentionPeriodInDays\": 3, \"KMSKeyArn\": \"" + KMS_KEY_ARN + "\"}")+ .statusCode(200)+ .body("DurableConfig.ExecutionTimeout", equalTo(7200))+ .body("DurableConfig.RetentionPeriodInDays", equalTo(3))+ .body("DurableConfig.KMSKeyArn", equalTo(KMS_KEY_ARN));++ updateDurableConfig("durable-update-fn", "{}")+ .statusCode(200)+ .body("DurableConfig.ExecutionTimeout", equalTo(7200))+ .body("DurableConfig.RetentionPeriodInDays", equalTo(3));++ getConfiguration("durable-update-fn", "?Qualifier=1")+ .statusCode(200)+ .body("DurableConfig.ExecutionTimeout", equalTo(3600))+ .body("DurableConfig.RetentionPeriodInDays", equalTo(7))+ .body("DurableConfig", not(hasKey("KMSKeyArn")));+ }++ @Test+ void updateCannotAddDurableConfigToAPlainFunction() {+ createFunction("plain-stays-plain-fn", "").statusCode(201);++ updateDurableConfig("plain-stays-plain-fn", "{\"ExecutionTimeout\": 60}")+ .statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", equalTo("You cannot add a durable configuration to a function that was "+ + "originally created with no durable configuration"));++ getConfiguration("plain-stays-plain-fn")+ .statusCode(200)+ .body("$", not(hasKey("DurableConfig")));+ }++ private static ValidatableResponse updateDurableConfig(String name, String durableConfig) {+ return updateConfiguration(name, "{\"DurableConfig\": " + durableConfig + "}");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServicePersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServicePersistenceTest.javaindex fc2db7f616..c16bbfd149 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServicePersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServicePersistenceTest.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.lambda;import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.InMemoryStorage;@@ -14,6 +15,7 @@ import org.junit.jupiter.api.Test;import java.nio.file.Path;import java.util.HashMap;+import java.util.List;import java.util.Map;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -50,6 +52,27 @@ class LambdaServicePersistenceTest {assertTrue(third.getFunctionArn().endsWith(":3"));}+ @Test+ void durableConfigSurvivesRestartAndJsonRoundTrip() throws Exception {+ SharedStorageFactory storage = new SharedStorageFactory();+ LambdaFunctionStore store = new LambdaFunctionStore(storage);++ LambdaService first = serviceWithStorage(store, storage);+ Map<String, Object> request = baseRequest("durable-fn");+ request.put("DurableConfig", Map.of("ExecutionTimeout", 3600));+ first.createFunction(REGION, request);++ LambdaService reloaded = serviceWithStorage(store, storage);+ LambdaFunction fn = reloaded.getFunction(REGION, "durable-fn");+ ObjectMapper mapper = new ObjectMapper();+ LambdaFunction copy = mapper.readValue(mapper.writeValueAsString(fn), LambdaFunction.class);+ for (LambdaFunction function : List.of(fn, copy)) {+ assertTrue(function.isDurable());+ assertEquals(3600, function.getDurableExecutionTimeout());+ assertEquals(14, function.getDurableRetentionPeriodInDays());+ }+ }+@Testvoid eventInvokeConfigSurvivesRestartIncludingUpdates() {SharedStorageFactory storage = new SharedStorageFactory();diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaStructureSerializationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaStructureSerializationIntegrationTest.javaindex 15a6a37268..cc2a0ba58b 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaStructureSerializationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaStructureSerializationIntegrationTest.java@@ -18,7 +18,7 @@ class LambdaStructureSerializationIntegrationTest {private static final String QUEUE_ARN = "arn:aws:sqs:us-east-1:000000000000:structure-queue";private static final List<String> FUNCTION_STRUCTURE_MEMBERS = List.of("Environment", "EphemeralStorage", "TracingConfig", "DeadLetterConfig",- "VpcConfig", "SnapStart", "LoggingConfig", "ImageConfig");+ "VpcConfig", "SnapStart", "LoggingConfig", "ImageConfig", "DurableConfig");@Testvoid createFunctionRejectsScalarStructureMembers() {