Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(lambda): return VpcConfig, SnapStart and LoggingConfig from every read path (#2527)

Allen Sanborn94795dd67b69
diff --git a/docs/services/lambda.md b/docs/services/lambda.md
index 045612cb8f..754d0e2d8d 100644
--- a/docs/services/lambda.md
+++ b/docs/services/lambda.md
@@ -446,6 +446,44 @@ 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 a
non-root user) can bind UDP/53 without any changes to your Compose file.
+### VpcConfig, SnapStart and LoggingConfig
+
+All three round-trip through `CreateFunction`, `UpdateFunctionConfiguration`,
+`GetFunctionConfiguration`, `GetFunction`, `ListFunctions` and `PublishVersion`.
+
+The response shapes are **not** the request shapes, and Floci follows the AWS model
+rather than echoing the request back:
+
+| Field | Request shape | Response shape | Extra members Floci fills in |
+|---|---|---|---|
+| `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` | — |
+
+`SnapStart` and `LoggingConfig` are always present in a response, as on AWS: an
+unset function reads back `SnapStart={ApplyOn: None, OptimizationStatus: Off}` and
+`LoggingConfig={LogFormat: Text, LogGroup: /aws/lambda/<name>}`. With
+`LogFormat=JSON`, `ApplicationLogLevel` and `SystemLogLevel` are also returned,
+defaulting to `INFO`. Terraform treats these as `Computed` blocks, so a missing one
+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.
+
+`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 the
+resolved format is `JSON`; supplying them with `LogFormat=Text` is not an error, it is
+simply a no-op, matching the fact that the response never surfaces them for Text.
+
+`VpcConfig` is omitted entirely while the function is not attached to a VPC.
+Subnets that EC2 does not know about are still accepted and returned; only `VpcId`
+is left off in that case.
+
+`RuntimeVersionConfig.RuntimeVersionArn` is returned for managed (non-image)
+runtimes. Its value is derived from the runtime name, so it is stable across
+restarts.
+
### File system configs
`FileSystemConfigs` accepts one EFS access point and mounts it under the
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 a344eefd2a..b1bc49bf24 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
@@ -28,9 +28,13 @@ import jakarta.ws.rs.core.UriBuilder;
import jakarta.ws.rs.core.UriInfo;
import org.jboss.logging.Logger;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
+import java.util.HexFormat;
import java.util.List;
import java.util.Map;
@@ -660,8 +664,109 @@ public class LambdaController {
fn.getEnvironment().forEach(vars::put);
}
+ putVpcConfig(node, fn);
+ putSnapStart(node, fn);
+ putLoggingConfig(node, fn);
+ putRuntimeVersionConfig(node, fn);
+
@SuppressWarnings("unchecked")
Map<String, Object> result = objectMapper.convertValue(node, Map.class);
return result;
}
+
+ /**
+ * 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 — AWS
+ * omits the block entirely once the last subnet and security group are removed.
+ */
+ private void putVpcConfig(ObjectNode node, LambdaFunction fn) {
+ Map<String, Object> vpcConfig = fn.getVpcConfig();
+ List<String> subnetIds = stringList(vpcConfig, "SubnetIds");
+ List<String> securityGroupIds = stringList(vpcConfig, "SecurityGroupIds");
+ if (subnetIds.isEmpty() && securityGroupIds.isEmpty()) {
+ return;
+ }
+ ObjectNode vpcNode = node.putObject("VpcConfig");
+ ArrayNode subnetNode = vpcNode.putArray("SubnetIds");
+ subnetIds.forEach(subnetNode::add);
+ ArrayNode securityGroupNode = vpcNode.putArray("SecurityGroupIds");
+ securityGroupIds.forEach(securityGroupNode::add);
+ if (fn.getVpcId() != null) {
+ vpcNode.put("VpcId", fn.getVpcId());
+ }
+ vpcNode.put("Ipv6AllowedForDualStack",
+ Boolean.TRUE.equals(vpcConfig.get("Ipv6AllowedForDualStack")));
+ }
+
+ /**
+ * SnapStartResponse, not SnapStart: the response adds OptimizationStatus, which the request
+ * shape has no member for. AWS only reports {@code On} for a published version whose snapshot
+ * has been optimized; {@code $LATEST} is always {@code Off} even with ApplyOn set.
+ */
+ private void putSnapStart(ObjectNode node, LambdaFunction fn) {
+ String applyOn = fn.getSnapStartApplyOn() != null ? fn.getSnapStartApplyOn() : "None";
+ boolean optimized = "PublishedVersions".equals(applyOn) && !"$LATEST".equals(fn.getVersion());
+ node.putObject("SnapStart")
+ .put("ApplyOn", applyOn)
+ .put("OptimizationStatus", optimized ? "On" : "Off");
+ }
+
+ /**
+ * Always present, as on AWS: an unset LoggingConfig still reads back as Text plus the default
+ * {@code /aws/lambda/<name>} log group. The two log levels are JSON-format-only.
+ */
+ private void putLoggingConfig(ObjectNode node, LambdaFunction fn) {
+ String logFormat = fn.getLogFormat() != null ? fn.getLogFormat() : "Text";
+ ObjectNode logging = node.putObject("LoggingConfig");
+ logging.put("LogFormat", logFormat);
+ if ("JSON".equals(logFormat)) {
+ logging.put("ApplicationLogLevel",
+ fn.getApplicationLogLevel() != null ? fn.getApplicationLogLevel() : "INFO");
+ logging.put("SystemLogLevel",
+ fn.getSystemLogLevel() != null ? fn.getSystemLogLevel() : "INFO");
+ }
+ logging.put("LogGroup", fn.getLogGroup() != null && !fn.getLogGroup().isBlank()
+ ? fn.getLogGroup()
+ : "/aws/lambda/" + fn.getFunctionName());
+ }
+
+ /** Managed-runtime only: AWS omits it for container images, which pin their own runtime. */
+ private void putRuntimeVersionConfig(ObjectNode node, LambdaFunction fn) {
+ if ("Image".equals(fn.getPackageType()) || fn.getRuntime() == null || fn.getRuntime().isBlank()) {
+ return;
+ }
+ node.putObject("RuntimeVersionConfig")
+ .put("RuntimeVersionArn", runtimeVersionArn(fn));
+ }
+
+ private static String runtimeVersionArn(LambdaFunction fn) {
+ String region = "us-east-1";
+ String[] arnParts = fn.getFunctionArn() != null ? fn.getFunctionArn().split(":") : new String[0];
+ if (arnParts.length > 3 && !arnParts[3].isBlank()) {
+ region = arnParts[3];
+ }
+ return "arn:aws:lambda:" + region + "::runtime:" + runtimeVersionId(fn.getRuntime());
+ }
+
+ /**
+ * AWS identifies a runtime version by a 64-hex digest. Derived from the runtime name so the
+ * same runtime keeps the same id across restarts — a value that churned would show up as a
+ * perpetual diff in anything that records it.
+ */
+ private static String runtimeVersionId(String runtime) {
+ try {
+ byte[] digest = MessageDigest.getInstance("SHA-256")
+ .digest(runtime.getBytes(StandardCharsets.UTF_8));
+ return HexFormat.of().formatHex(digest);
+ } catch (NoSuchAlgorithmException e) {
+ throw new IllegalStateException("SHA-256 unavailable", e);
+ }
+ }
+
+ private static List<String> stringList(Map<String, Object> config, String key) {
+ if (config == null || !(config.get(key) instanceof List<?> values)) {
+ return List.of();
+ }
+ return values.stream().filter(java.util.Objects::nonNull).map(Object::toString).toList();
+ }
}
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.java
index 2a5de66562..5e686e66f2 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
@@ -10,6 +10,8 @@ import io.github.hectorvent.floci.core.storage.StorageFactory;
import io.github.hectorvent.floci.core.resource.ExplorerResource;
import io.github.hectorvent.floci.core.resource.ResourceProvider;
import io.github.hectorvent.floci.core.resource.SupportedResourceType;
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
+import io.github.hectorvent.floci.services.ec2.model.Subnet;
import io.github.hectorvent.floci.services.lambda.model.EventSourceMapping;
import io.github.hectorvent.floci.services.lambda.model.FunctionEventInvokeConfig;
import io.github.hectorvent.floci.services.lambda.model.InvocationType;
@@ -59,6 +61,7 @@ public class LambdaService implements ResourceProvider {
+ "(?:(?:-gov)|(?:-iso(?:b)?))?-[a-z]+-\\d:"
+ "\\d{12}:access-point/fsap-[a-f0-9]{17}$");
private static final Pattern FILE_SYSTEM_LOCAL_MOUNT_PATH = Pattern.compile("^/mnt/[A-Za-z0-9._-]+$");
+ private static final Pattern LOG_GROUP_PATTERN = Pattern.compile("[.\\-_/#A-Za-z0-9]+");
private final LambdaFunctionStore functionStore;
private final LambdaExecutorService executorService;
@@ -77,6 +80,7 @@ public class LambdaService implements ResourceProvider {
private final DynamoDbStreamsEventSourcePoller dynamodbStreamsPoller;
private final StorageFactory storageFactory;
private final LambdaLayerService layerService;
+ private final Ec2Service ec2Service;
private Map<String, Integer> versionCounters = new ConcurrentHashMap<>();
private Map<String, FunctionEventInvokeConfig> eventInvokeConfigs = new ConcurrentHashMap<>();
/**
@@ -146,6 +150,7 @@ public class LambdaService implements ResourceProvider {
this.dynamodbStreamsPoller = null;
this.storageFactory = storageFactory;
this.layerService = null;
+ this.ec2Service = null;
}
@Inject
@@ -165,7 +170,8 @@ public class LambdaService implements ResourceProvider {
KinesisEventSourcePoller kinesisPoller,
DynamoDbStreamsEventSourcePoller dynamodbStreamsPoller,
StorageFactory storageFactory,
- LambdaLayerService layerService) {
+ LambdaLayerService layerService,
+ Ec2Service ec2Service) {
this.functionStore = functionStore;
this.executorService = executorService;
this.concurrencyLimiter = concurrencyLimiter;
@@ -183,6 +189,7 @@ public class LambdaService implements ResourceProvider {
this.dynamodbStreamsPoller = dynamodbStreamsPoller;
this.storageFactory = storageFactory;
this.layerService = layerService;
+ this.ec2Service = ec2Service;
}
// Real AWS validates a function's Layers eagerly at CreateFunction/UpdateFunctionConfiguration
@@ -384,8 +391,12 @@ public class LambdaService implements ResourceProvider {
@SuppressWarnings("unchecked")
Map<String, Object> vpc = (Map<String, Object>) request.get("VpcConfig");
fn.setVpcConfig(vpc);
+ fn.setVpcId(resolveVpcId(region, vpc));
}
+ applySnapStart(fn, request.get("SnapStart"));
+ applyLoggingConfig(fn, request.get("LoggingConfig"));
+
List<LambdaFileSystemConfig> fileSystemConfigs =
parseFileSystemConfigs(request.get("FileSystemConfigs"));
validateFileSystemVpcConfig(fileSystemConfigs, fn.getVpcConfig());
@@ -526,6 +537,12 @@ public class LambdaService implements ResourceProvider {
if (request.containsKey("Layers")) {
validateLayersResolvable(layerList);
}
+ if (request.containsKey("SnapStart")) {
+ validateSnapStart(request.get("SnapStart"));
+ }
+ if (request.containsKey("LoggingConfig")) {
+ validateLoggingConfig(request.get("LoggingConfig"));
+ }
Map<String, Object> requestedVpcConfig = fn.getVpcConfig();
if (request.get("VpcConfig") instanceof Map<?, ?>) {
@@ -619,9 +636,18 @@ public class LambdaService implements ResourceProvider {
if (request.containsKey("VpcConfig")) {
if (request.get("VpcConfig") instanceof Map<?, ?>) {
fn.setVpcConfig(requestedVpcConfig);
+ fn.setVpcId(resolveVpcId(region, requestedVpcConfig));
}
}
+ if (request.containsKey("SnapStart")) {
+ applySnapStart(fn, request.get("SnapStart"));
+ }
+
+ if (request.containsKey("LoggingConfig")) {
+ applyLoggingConfig(fn, request.get("LoggingConfig"));
+ }
+
if (request.containsKey("FileSystemConfigs")) {
fn.setFileSystemConfigs(requestedFileSystemConfigs);
}
@@ -1137,6 +1163,12 @@ public class LambdaService implements ResourceProvider {
snapshot.setVpcConfig(fn.getVpcConfig() == null
? null
: new java.util.HashMap<>(fn.getVpcConfig()));
+ snapshot.setVpcId(fn.getVpcId());
+ snapshot.setSnapStartApplyOn(fn.getSnapStartApplyOn());
+ snapshot.setLogFormat(fn.getLogFormat());
+ snapshot.setApplicationLogLevel(fn.getApplicationLogLevel());
+ snapshot.setSystemLogLevel(fn.getSystemLogLevel());
+ snapshot.setLogGroup(fn.getLogGroup());
snapshot.setFileSystemConfigs(new ArrayList<>(fn.getFileSystemConfigs()));
snapshot.setLastModified(System.currentTimeMillis());
snapshot.setRevisionId(UUID.randomUUID().toString());
@@ -1219,6 +1251,118 @@ public class LambdaService implements ResourceProvider {
}
}
+ /**
+ * The VpcConfig request shape carries no VpcId; VpcConfigResponse does. AWS derives it from
+ * the subnets the function is attached to, so resolve it once at attach time and store it.
+ * A subnet EC2 has never heard of resolves to null rather than failing the call - Floci's
+ * Lambda accepts unmanaged subnet ids, and CreateFunction must not start rejecting them.
+ */
+ private String resolveVpcId(String region, Map<String, Object> vpcConfig) {
+ if (ec2Service == null || !hasValues(vpcConfig, "SubnetIds")) {
+ return null;
+ }
+ for (Object subnetId : (List<?>) vpcConfig.get("SubnetIds")) {
+ if (subnetId == null) {
+ continue;
+ }
+ try {
+ List<Subnet> found = ec2Service.describeSubnets(region, List.of(subnetId.toString()), Map.of());
+ if (!found.isEmpty() && found.get(0).getVpcId() != null) {
+ return found.get(0).getVpcId();
+ }
+ } catch (RuntimeException e) {
+ LOG.debugv(e, "Could not resolve VpcId for subnet {0} in {1}", subnetId, region);
+ }
+ }
+ return null;
+ }
+
+ private static void validateSnapStart(Object value) {
+ if (!(value instanceof Map<?, ?> snapStart)) {
+ return;
+ }
+ Object applyOn = snapStart.get("ApplyOn");
+ if (applyOn != null && !"None".equals(applyOn) && !"PublishedVersions".equals(applyOn)) {
+ throw new AwsException("ValidationException",
+ "1 validation error detected: Value '" + applyOn + "' at 'snapStart.applyOn' failed to "
+ + "satisfy constraint: Member must satisfy enum value set: "
+ + "[PublishedVersions, None]", 400);
+ }
+ }
+
+ private static void applySnapStart(LambdaFunction fn, Object value) {
+ if (!(value instanceof Map<?, ?> snapStart)) {
+ return;
+ }
+ validateSnapStart(value);
+ Object applyOn = snapStart.get("ApplyOn");
+ fn.setSnapStartApplyOn(applyOn instanceof String s && !s.isBlank() ? s : "None");
+ }
+
+ private static void validateLoggingConfig(Object value) {
+ if (!(value instanceof Map<?, ?> logging)) {
+ return;
+ }
+ validateEnum(logging.get("LogFormat"), "loggingConfig.logFormat", List.of("JSON", "Text"));
+ validateEnum(logging.get("ApplicationLogLevel"), "loggingConfig.applicationLogLevel",
+ List.of("TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"));
+ validateEnum(logging.get("SystemLogLevel"), "loggingConfig.systemLogLevel",
+ List.of("DEBUG", "INFO", "WARN"));
+ validateLogGroup(logging.get("LogGroup"));
+ }
+
+ private static void validateEnum(Object value, String field, List<String> allowed) {
+ if (value == null || allowed.contains(value)) {
+ return;
+ }
+ throw new AwsException("ValidationException",
+ "1 validation error detected: Value '" + value + "' at '" + field + "' failed to satisfy "
+ + "constraint: Member must satisfy enum value set: ["
+ + String.join(", ", allowed) + "]", 400);
+ }
+
+ /**
+ * LogGroup is the one LoggingConfig member with a documented length and character
+ * constraint rather than an enum: 1-512 characters, {@code [.\-_/#A-Za-z0-9]+}.
+ */
+ private static void validateLogGroup(Object value) {
+ if (!(value instanceof String group) || group.isBlank()) {
+ return;
+ }
+ if (group.length() > 512 || !LOG_GROUP_PATTERN.matcher(group).matches()) {
+ throw new AwsException("ValidationException",
+ "1 validation error detected: Value '" + group + "' at 'loggingConfig.logGroup' failed to "
+ + "satisfy constraint: Member must satisfy regular expression pattern: "
+ + "[.\\-_/#A-Za-z0-9]+ or member must have length less than or equal to 512", 400);
+ }
+ }
+
+ /**
+ * LoggingConfig is replaced wholesale, not merged: AWS resets any member the request omits
+ * back to its default, so an update that names only LogFormat drops a previously set LogGroup.
+ *
+ * <p>ApplicationLogLevel and SystemLogLevel are JSON-format-only: {@link #putLoggingConfig}
+ * never surfaces them for a Text-format function. Storing them anyway would leave state
+ * that is accepted, persisted and then never observable through any read path — the same
+ * accepted-then-forgotten shape this fix removes elsewhere — so they are only kept when the
+ * resolved format is JSON.
+ */
+ private static void applyLoggingConfig(LambdaFunction fn, Object value) {
+ if (!(value instanceof Map<?, ?> logging)) {
+ return;
+ }
+ validateLoggingConfig(value);
+ String format = logging.get("LogFormat") instanceof String f && !f.isBlank() ? f : "Text";
+ boolean json = "JSON".equals(format);
+ fn.setLogFormat(format);
+ fn.setApplicationLogLevel(json && logging.get("ApplicationLogLevel") instanceof String level
+ && !level.isBlank() ? level : null);
+ fn.setSystemLogLevel(json && logging.get("SystemLogLevel") instanceof String level
+ && !level.isBlank() ? level : null);
+ fn.setLogGroup(logging.get("LogGroup") instanceof String group && !group.isBlank()
+ ? group : null);
+ }
+
private static boolean hasValues(Map<String, Object> config, String key) {
return config != null
&& config.get(key) instanceof List<?> values
diff --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.java
index 2de33e447e..11e0707b16 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
@@ -49,6 +49,16 @@ public class LambdaFunction {
private List<String> layers = new ArrayList<>();
private String kmsKeyArn;
private Map<String, Object> vpcConfig;
+ /**
+ * Resolved at attach time from the first VpcConfig subnet. Response-only: the AWS model's
+ * VpcConfigResponse carries VpcId, while the VpcConfig request shape does not.
+ */
+ private String vpcId;
+ private String snapStartApplyOn = "None";
+ private String logFormat = "Text";
+ private String applicationLogLevel;
+ private String systemLogLevel;
+ private String logGroup;
private List<LambdaFileSystemConfig> fileSystemConfigs = new ArrayList<>();
private String codeSha256;
@@ -169,6 +179,24 @@ public class LambdaFunction {
public Map<String, Object> getVpcConfig() { return vpcConfig; }
public void setVpcConfig(Map<String, Object> vpcConfig) { this.vpcConfig = vpcConfig; }
+ public String getVpcId() { return vpcId; }
+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }
+
+ public String getSnapStartApplyOn() { return snapStartApplyOn; }
+ public void setSnapStartApplyOn(String snapStartApplyOn) { this.snapStartApplyOn = snapStartApplyOn; }
+
+ public String getLogFormat() { return logFormat; }
+ public void setLogFormat(String logFormat) { this.logFormat = logFormat; }
+
+ public String getApplicationLogLevel() { return applicationLogLevel; }
+ public void setApplicationLogLevel(String applicationLogLevel) { this.applicationLogLevel = applicationLogLevel; }
+
+ public String getSystemLogLevel() { return systemLogLevel; }
+ public void setSystemLogLevel(String systemLogLevel) { this.systemLogLevel = systemLogLevel; }
+
+ public String getLogGroup() { return logGroup; }
+ public void setLogGroup(String logGroup) { this.logGroup = logGroup; }
+
public List<LambdaFileSystemConfig> getFileSystemConfigs() { return fileSystemConfigs; }
public void setFileSystemConfigs(List<LambdaFileSystemConfig> fileSystemConfigs) {
this.fileSystemConfigs = fileSystemConfigs == null ? new ArrayList<>() : new ArrayList<>(fileSystemConfigs);
diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaArnInvocationAccountTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaArnInvocationAccountTest.java
index 0eb0ac3c25..8a5008fc64 100644
--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaArnInvocationAccountTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaArnInvocationAccountTest.java
@@ -66,6 +66,7 @@ class LambdaArnInvocationAccountTest {
null,
null,
null,
+ null,
null);
InvokeResult result = service.invokeArn(functionArn, "{}".getBytes(), InvocationType.Event);
@@ -125,6 +126,7 @@ class LambdaArnInvocationAccountTest {
null,
null,
null,
+ null,
null);
InvokeResult versionResult = service.invokeArn(
@@ -262,6 +264,7 @@ class LambdaArnInvocationAccountTest {
null,
null,
null,
+ null,
null);
}
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaVpcSnapStartLoggingIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaVpcSnapStartLoggingIntegrationTest.java
new file mode 100644
index 0000000000..dd66994ee8
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaVpcSnapStartLoggingIntegrationTest.java
@@ -0,0 +1,534 @@
+package io.github.hectorvent.floci.services.lambda;
+
+import io.github.hectorvent.floci.services.ec2.Ec2Service;
+import io.github.hectorvent.floci.services.ec2.model.Subnet;
+import io.quarkus.test.junit.QuarkusTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.Matchers.startsWith;
+
+/**
+ * VpcConfig, SnapStart and LoggingConfig must survive CreateFunction and
+ * UpdateFunctionConfiguration and read back from GetFunctionConfiguration / GetFunction.
+ * Terraform refreshes all three on every plan, so a field accepted and then dropped is a
+ * permanent non-converging diff rather than a cosmetic omission.
+ *
+ * <p>The request and response shapes deliberately differ: VpcConfigResponse adds VpcId and
+ * SnapStartResponse adds OptimizationStatus, neither of which the caller can send.
+ */
+@QuarkusTest
+class LambdaVpcSnapStartLoggingIntegrationTest {
+
+ private static final String BASE_PATH = "/2015-03-31";
+ private static final String REGION = "us-east-1";
+ private static final String SECURITY_GROUP_ID = "sg-0123456789abcdef0";
+
+ @Inject
+ Ec2Service ec2Service;
+
+ private String subnetId;
+ private String expectedVpcId;
+
+ @BeforeEach
+ void resolveSubnet() {
+ Subnet subnet = ec2Service.describeSubnets(REGION, List.of(), Map.of()).get(0);
+ subnetId = subnet.getSubnetId();
+ expectedVpcId = subnet.getVpcId();
+ }
+
+ private void createFunction(String name, String extraJson) {
+ createFunction(name, "nodejs20.x", extraJson);
+ }
+
+ /**
+ * SnapStart is only available on a subset of managed runtimes (Java 11+, Python 3.12+,
+ * .NET 8+); {@code nodejs20.x} is not among them. Tests that exercise SnapStart use this
+ * overload with a supported runtime so they don't lock in a create AWS would reject.
+ */
+ private void createFunction(String name, String runtime, String extraJson) {
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "%s",
+ "Runtime": "%s",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler"%s
+ }
+ """.formatted(name, runtime, extraJson))
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(201);
+ }
+
+ private String vpcConfigJson() {
+ return """
+ ,
+ "VpcConfig": {
+ "SubnetIds": ["%s"],
+ "SecurityGroupIds": ["%s"]
+ }""".formatted(subnetId, SECURITY_GROUP_ID);
+ }
+
+ @Test
+ void createFunctionReturnsVpcConfigWithResolvedVpcId() {
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "vpc-create-fn",
+ "Runtime": "nodejs20.x",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler"%s
+ }
+ """.formatted(vpcConfigJson()))
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(201)
+ .body("VpcConfig.SubnetIds", contains(subnetId))
+ .body("VpcConfig.SecurityGroupIds", contains(SECURITY_GROUP_ID))
+ .body("VpcConfig.VpcId", equalTo(expectedVpcId))
+ .body("VpcConfig.Ipv6AllowedForDualStack", equalTo(false));
+ }
+
+ @Test
+ void getFunctionConfigurationReturnsVpcConfig() {
+ createFunction("vpc-get-config-fn", vpcConfigJson());
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/vpc-get-config-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig.SubnetIds", contains(subnetId))
+ .body("VpcConfig.SecurityGroupIds", contains(SECURITY_GROUP_ID))
+ .body("VpcConfig.VpcId", equalTo(expectedVpcId));
+ }
+
+ @Test
+ void getFunctionReturnsVpcConfig() {
+ createFunction("vpc-get-fn", vpcConfigJson());
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/vpc-get-fn")
+ .then()
+ .statusCode(200)
+ .body("Configuration.VpcConfig.SubnetIds", contains(subnetId))
+ .body("Configuration.VpcConfig.SecurityGroupIds", contains(SECURITY_GROUP_ID))
+ .body("Configuration.VpcConfig.VpcId", equalTo(expectedVpcId));
+ }
+
+ @Test
+ void updateFunctionConfigurationAttachesVpcAndRoundTrips() {
+ createFunction("vpc-update-fn", "");
+
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "VpcConfig": {
+ "SubnetIds": ["%s"],
+ "SecurityGroupIds": ["%s"]
+ }
+ }
+ """.formatted(subnetId, SECURITY_GROUP_ID))
+ .when()
+ .put(BASE_PATH + "/functions/vpc-update-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig.SubnetIds", contains(subnetId))
+ .body("VpcConfig.VpcId", equalTo(expectedVpcId));
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/vpc-update-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig.SubnetIds", contains(subnetId))
+ .body("VpcConfig.SecurityGroupIds", contains(SECURITY_GROUP_ID))
+ .body("VpcConfig.VpcId", equalTo(expectedVpcId));
+ }
+
+ @Test
+ void vpcConfigIsAbsentWhenTheFunctionIsNotAttached() {
+ createFunction("vpc-absent-fn", "");
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/vpc-absent-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig", nullValue());
+ }
+
+ @Test
+ void unknownSubnetStillRoundTripsWithoutVpcId() {
+ createFunction("vpc-unmanaged-subnet-fn", """
+ ,
+ "VpcConfig": {
+ "SubnetIds": ["subnet-ffffffffffffffff0"],
+ "SecurityGroupIds": ["%s"]
+ }""".formatted(SECURITY_GROUP_ID));
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/vpc-unmanaged-subnet-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig.SubnetIds", contains("subnet-ffffffffffffffff0"))
+ .body("VpcConfig.VpcId", nullValue());
+ }
+
+ @Test
+ void snapStartAndLoggingConfigDefaultsArePopulatedWhenUnset() {
+ createFunction("defaults-fn", "");
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/defaults-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("SnapStart.ApplyOn", equalTo("None"))
+ .body("SnapStart.OptimizationStatus", equalTo("Off"))
+ .body("LoggingConfig.LogFormat", equalTo("Text"))
+ .body("LoggingConfig.LogGroup", equalTo("/aws/lambda/defaults-fn"))
+ .body("LoggingConfig.ApplicationLogLevel", nullValue())
+ .body("RuntimeVersionConfig.RuntimeVersionArn", startsWith("arn:aws:lambda:us-east-1::runtime:"));
+ }
+
+ @Test
+ void snapStartRoundTripsAndOptimizationStatusIsResponseOnly() {
+ createFunction("snapstart-fn", "java21", """
+ ,
+ "SnapStart": {"ApplyOn": "PublishedVersions"}""");
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/snapstart-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("SnapStart.ApplyOn", equalTo("PublishedVersions"))
+ .body("SnapStart.OptimizationStatus", equalTo("Off"));
+
+ given()
+ .contentType("application/json")
+ .body("{}")
+ .when()
+ .post(BASE_PATH + "/functions/snapstart-fn/versions")
+ .then()
+ .statusCode(201)
+ .body("SnapStart.ApplyOn", equalTo("PublishedVersions"))
+ .body("SnapStart.OptimizationStatus", equalTo("On"));
+ }
+
+ @Test
+ void updateFunctionConfigurationRoundTripsSnapStart() {
+ createFunction("snapstart-update-fn", "java21", "");
+
+ given()
+ .contentType("application/json")
+ .body("{\"SnapStart\": {\"ApplyOn\": \"PublishedVersions\"}}")
+ .when()
+ .put(BASE_PATH + "/functions/snapstart-update-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("SnapStart.ApplyOn", equalTo("PublishedVersions"));
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/snapstart-update-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("SnapStart.ApplyOn", equalTo("PublishedVersions"));
+ }
+
+ @Test
+ void snapStartRejectsValueOutsideTheEnum() {
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "snapstart-invalid-fn",
+ "Runtime": "nodejs20.x",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler",
+ "SnapStart": {"ApplyOn": "Always"}
+ }
+ """)
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo("1 validation error detected: Value 'Always' at 'snapStart.applyOn' "
+ + "failed to satisfy constraint: Member must satisfy enum value set: "
+ + "[PublishedVersions, None]"));
+ }
+
+ @Test
+ void jsonLoggingConfigRoundTripsWithLogLevels() {
+ createFunction("logging-json-fn", """
+ ,
+ "LoggingConfig": {
+ "LogFormat": "JSON",
+ "ApplicationLogLevel": "DEBUG",
+ "SystemLogLevel": "WARN",
+ "LogGroup": "/custom/log/group"
+ }""");
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/logging-json-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("LoggingConfig.LogFormat", equalTo("JSON"))
+ .body("LoggingConfig.ApplicationLogLevel", equalTo("DEBUG"))
+ .body("LoggingConfig.SystemLogLevel", equalTo("WARN"))
+ .body("LoggingConfig.LogGroup", equalTo("/custom/log/group"));
+ }
+
+ @Test
+ void jsonLoggingConfigDefaultsBothLogLevelsToInfo() {
+ createFunction("logging-json-default-fn", """
+ ,
+ "LoggingConfig": {"LogFormat": "JSON"}""");
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/logging-json-default-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("LoggingConfig.LogFormat", equalTo("JSON"))
+ .body("LoggingConfig.ApplicationLogLevel", equalTo("INFO"))
+ .body("LoggingConfig.SystemLogLevel", equalTo("INFO"))
+ .body("LoggingConfig.LogGroup", equalTo("/aws/lambda/logging-json-default-fn"));
+ }
+
+ @Test
+ void updateFunctionConfigurationReplacesLoggingConfigWholesale() {
+ createFunction("logging-update-fn", """
+ ,
+ "LoggingConfig": {
+ "LogFormat": "JSON",
+ "ApplicationLogLevel": "DEBUG",
+ "LogGroup": "/custom/log/group"
+ }""");
+
+ given()
+ .contentType("application/json")
+ .body("{\"LoggingConfig\": {\"LogFormat\": \"Text\"}}")
+ .when()
+ .put(BASE_PATH + "/functions/logging-update-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("LoggingConfig.LogFormat", equalTo("Text"))
+ .body("LoggingConfig.LogGroup", equalTo("/aws/lambda/logging-update-fn"));
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/logging-update-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("LoggingConfig.LogFormat", equalTo("Text"))
+ .body("LoggingConfig.ApplicationLogLevel", nullValue())
+ .body("LoggingConfig.LogGroup", equalTo("/aws/lambda/logging-update-fn"));
+ }
+
+ @Test
+ void loggingConfigRejectsLogFormatOutsideTheEnum() {
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "logging-invalid-fn",
+ "Runtime": "nodejs20.x",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler",
+ "LoggingConfig": {"LogFormat": "YAML"}
+ }
+ """)
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo("1 validation error detected: Value 'YAML' at 'loggingConfig.logFormat' "
+ + "failed to satisfy constraint: Member must satisfy enum value set: [JSON, Text]"));
+ }
+
+ @Test
+ void loggingConfigRejectsApplicationLogLevelOutsideTheEnum() {
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "logging-invalid-app-level-fn",
+ "Runtime": "nodejs20.x",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler",
+ "LoggingConfig": {"LogFormat": "JSON", "ApplicationLogLevel": "VERBOSE"}
+ }
+ """)
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo("1 validation error detected: Value 'VERBOSE' at "
+ + "'loggingConfig.applicationLogLevel' failed to satisfy constraint: Member must satisfy "
+ + "enum value set: [TRACE, DEBUG, INFO, WARN, ERROR, FATAL]"));
+ }
+
+ @Test
+ void loggingConfigRejectsSystemLogLevelOutsideTheEnum() {
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "logging-invalid-system-level-fn",
+ "Runtime": "nodejs20.x",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler",
+ "LoggingConfig": {"LogFormat": "JSON", "SystemLogLevel": "TRACE"}
+ }
+ """)
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"))
+ .body("message", equalTo("1 validation error detected: Value 'TRACE' at "
+ + "'loggingConfig.systemLogLevel' failed to satisfy constraint: Member must satisfy "
+ + "enum value set: [DEBUG, INFO, WARN]"));
+ }
+
+ @Test
+ void loggingConfigRejectsLogGroupOutsideTheDocumentedPattern() {
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "logging-invalid-group-fn",
+ "Runtime": "nodejs20.x",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler",
+ "LoggingConfig": {"LogGroup": "my log group"}
+ }
+ """)
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"));
+ }
+
+ @Test
+ void loggingConfigRejectsLogGroupLongerThanFiveHundredTwelveCharacters() {
+ String tooLong = "a".repeat(513);
+
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "FunctionName": "logging-invalid-long-group-fn",
+ "Runtime": "nodejs20.x",
+ "Role": "arn:aws:iam::000000000000:role/lambda-role",
+ "Handler": "index.handler",
+ "LoggingConfig": {"LogGroup": "%s"}
+ }
+ """.formatted(tooLong))
+ .when()
+ .post(BASE_PATH + "/functions")
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ValidationException"));
+ }
+
+ @Test
+ void textFormatLogLevelsAreAcceptedButNeverStoredOrReturned() {
+ createFunction("logging-text-levels-fn", """
+ ,
+ "LoggingConfig": {
+ "LogFormat": "Text",
+ "ApplicationLogLevel": "DEBUG",
+ "SystemLogLevel": "WARN"
+ }""");
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/logging-text-levels-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("LoggingConfig.LogFormat", equalTo("Text"))
+ .body("LoggingConfig.ApplicationLogLevel", nullValue())
+ .body("LoggingConfig.SystemLogLevel", nullValue());
+ }
+
+ @Test
+ void updateFunctionConfigurationDetachesVpcConfigAndClearsVpcId() {
+ createFunction("vpc-detach-fn", vpcConfigJson());
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/vpc-detach-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig.VpcId", equalTo(expectedVpcId));
+
+ given()
+ .contentType("application/json")
+ .body("""
+ {
+ "VpcConfig": {
+ "SubnetIds": [],
+ "SecurityGroupIds": []
+ }
+ }
+ """)
+ .when()
+ .put(BASE_PATH + "/functions/vpc-detach-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig", nullValue());
+
+ given()
+ .when()
+ .get(BASE_PATH + "/functions/vpc-detach-fn/configuration")
+ .then()
+ .statusCode(200)
+ .body("VpcConfig", nullValue());
+ }
+
+ @Test
+ void publishedVersionCarriesVpcAndLoggingConfig() {
+ createFunction("version-carry-fn", vpcConfigJson() + """
+ ,
+ "LoggingConfig": {"LogFormat": "JSON", "LogGroup": "/custom/version/group"}""");
+
+ given()
+ .contentType("application/json")
+ .body("{}")
+ .when()
+ .post(BASE_PATH + "/functions/version-carry-fn/versions")
+ .then()
+ .statusCode(201)
+ .body("Version", notNullValue())
+ .body("VpcConfig.SubnetIds", contains(subnetId))
+ .body("VpcConfig.VpcId", equalTo(expectedVpcId))
+ .body("LoggingConfig.LogFormat", equalTo("JSON"))
+ .body("LoggingConfig.LogGroup", equalTo("/custom/version/group"));
+ }
+}