Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): give published versions their code location (#2012)
Bill DeMoss42022fe9375d
diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.java b/src/main/java/io/github/hectorvent/floci/services/lambda/LambdaService.javaindex a283395ad2..627bcee3d4 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@@ -979,6 +979,27 @@ public class LambdaService {snapshot.setLastModified(System.currentTimeMillis());snapshot.setRevisionId(UUID.randomUUID().toString());+ // Everything that determines what actually runs. Without these the snapshot describes a+ // function with no code: a version-qualified invoke resolves to it, launches a container+ // with nothing in it, and hangs to the function timeout instead of failing (#1987). A+ // published version is an immutable snapshot of code plus configuration, so it carries the+ // code location for every package type, not only Zip.+ snapshot.setCodeLocalPath(fn.getCodeLocalPath());+ snapshot.setCodeSha256(fn.getCodeSha256());+ snapshot.setS3Bucket(fn.getS3Bucket());+ snapshot.setS3Key(fn.getS3Key());+ snapshot.setHotReloadHostPath(fn.getHotReloadHostPath());+ snapshot.setImageUri(fn.getImageUri());+ snapshot.setImageConfigCommand(fn.getImageConfigCommand());+ snapshot.setImageConfigEntryPoint(fn.getImageConfigEntryPoint());+ snapshot.setImageConfigWorkingDirectory(fn.getImageConfigWorkingDirectory());+ snapshot.setLayers(fn.getLayers());+ snapshot.setArchitectures(fn.getArchitectures());+ snapshot.setEphemeralStorageSize(fn.getEphemeralStorageSize());+ snapshot.setTracingMode(fn.getTracingMode());+ snapshot.setDeadLetterTargetArn(fn.getDeadLetterTargetArn());+ snapshot.setKmsKeyArn(fn.getKmsKeyArn());+functionStore.save(region, snapshot);LOG.infov("Published version {0} for function {1}", version, functionName);return snapshot;diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.javaindex 3ad399afd6..d7f66aa32b 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/launcher/ContainerLauncher.java@@ -156,14 +156,24 @@ public class ContainerLauncher {// For Zip functions, verify code exists before allocating any resources.// Hot-reload functions use a bind-mount; the Docker daemon validates the path at start.- if (!fn.isHotReload()) {- if (fn.getCodeLocalPath() != null) {- Path codePath = Path.of(fn.getCodeLocalPath());- if (!Files.exists(codePath)) {- throw new RuntimeException("Code directory not found for function '"- + fn.getFunctionName() + "': " + fn.getCodeLocalPath()- + " (function may have been deleted or updated)");- }+ // Image functions carry an imageUri rather than a local path.+ if (!fn.isHotReload() && !"Image".equals(fn.getPackageType())) {+ if (fn.getCodeLocalPath() == null) {+ // A null path used to skip validation entirely, which made the one state that+ // always means "no code" the one state never checked: the container started+ // empty, the runtime logged an ImportModuleError nobody saw, and the caller+ // waited out the whole function timeout. Failing here surfaces a dropped code+ // field at its cause instead of as a timeout somewhere else (#1987).+ throw new RuntimeException("No code location for function '"+ + fn.getFunctionName() + "'"+ + ("$LATEST".equals(fn.getVersion()) ? "" : " version " + fn.getVersion())+ + " (function has no deployed code)");+ }+ Path codePath = Path.of(fn.getCodeLocalPath());+ if (!Files.exists(codePath)) {+ throw new RuntimeException("Code directory not found for function '"+ + fn.getFunctionName() + "': " + fn.getCodeLocalPath()+ + " (function may have been deleted or updated)");}}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.javaindex 2e74af061e..67b0b3364b 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaImageConfigTest.java@@ -25,6 +25,7 @@ import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Nested;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.extension.ExtendWith;+import org.junit.jupiter.api.io.TempDir;import org.mockito.ArgumentCaptor;import org.mockito.Mock;import org.mockito.junit.jupiter.MockitoExtension;@@ -349,12 +350,16 @@ class LambdaImageConfigTest {}@Test- void zipFunctionStillUsesHandlerAsCmd() throws Exception {+ void zipFunctionStillUsesHandlerAsCmd(@TempDir Path codeDir) throws Exception {LambdaFunction fn = new LambdaFunction();fn.setFunctionName("zip-fn");fn.setRuntime("nodejs20.x");fn.setHandler("index.handler");fn.setPackageType("Zip");+ // A Zip function needs a code location — launch() now rejects one without it instead+ // of starting an empty container. This test covers cmd construction, so any real+ // directory will do.+ fn.setCodeLocalPath(codeDir.toString());when(imageResolver.resolve("nodejs20.x")).thenReturn("public.ecr.aws/lambda/nodejs:20");launcher.launch(fn);diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaVersionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaVersionIntegrationTest.javaindex c93630ba02..e5bb7a8859 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaVersionIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaVersionIntegrationTest.java@@ -6,6 +6,11 @@ import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;+import java.io.ByteArrayOutputStream;+import java.util.Base64;+import java.util.zip.ZipEntry;+import java.util.zip.ZipOutputStream;+import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.*;@@ -125,4 +130,160 @@ class LambdaVersionIntegrationTest {.then().statusCode(404);}++ @Test+ @Order(7)+ void invokeLatest_baselineRunsTheCode() throws Exception {+ // Baseline for the case below. Every other test in this file uses a function with no code+ // at all, so none of them can invoke; this pins that the zip, runtime and harness are+ // sound, which is what makes a failure in the next test attributable to versioning.+ // Deliberately a SEPARATE function: invoking $LATEST on the function under test would+ // leave a warm container that the version invoke then reuses.+ String fnName = "version-invoke-baseline";+ createInvocableFunction(fnName);++ try {+ given()+ .contentType("application/json")+ .body("{}")+ .when()+ .post(BASE_PATH + "/functions/" + fnName + "/invocations")+ .then()+ .statusCode(200)+ .header("X-Amz-Function-Error", nullValue())+ .body("ok", equalTo(true));+ } finally {+ given().delete(BASE_PATH + "/functions/" + fnName);+ }+ }++ @Test+ @Order(8)+ void invokePublishedVersion_runsTheVersionsCode() throws Exception {+ // A published version is only useful if it can be invoked, and nothing in this file+ // exercised that. publishVersion copies 14 fields onto the snapshot but no code location+ // (codeLocalPath, s3Bucket/s3Key, imageUri are all dropped), and ContainerLauncher.launch+ // only validates the code path when it is non-null — so a null one skips validation, the+ // container starts with nothing to run, and the invoke times out rather than throwing.+ String fnName = "version-invoke-cold";+ createInvocableFunction(fnName);++ try {+ given()+ .contentType("application/json")+ .body("{\"Description\": \"invocable\"}")+ .when()+ .post(BASE_PATH + "/functions/" + fnName + "/versions")+ .then()+ .statusCode(201)+ .body("Version", equalTo("1"));++ // The version invoke must be a COLD start to mean anything. $LATEST is never invoked+ // on this function: the warm pool is keyed by function name alone (#1988), so a warm+ // container from a $LATEST invoke gets handed to a version-qualified one and serves+ // $LATEST's code — which makes this assertion pass while the version path is broken.+ given()+ .contentType("application/json")+ .body("{}")+ .when()+ .post(BASE_PATH + "/functions/" + fnName + ":1/invocations")+ .then()+ .statusCode(200)+ // Body first: the header assertion below fails fast and would otherwise mask what+ // the version actually returned.+ .body("ok", equalTo(true))+ .header("X-Amz-Function-Error", nullValue());+ } finally {+ given().delete(BASE_PATH + "/functions/" + fnName);+ }+ }++ @Test+ @Order(9)+ void publishVersion_copiesObservabilityAndEncryptionConfig() {+ // A published version is an immutable snapshot of configuration too, not only code.+ // TracingConfig, DeadLetterConfig and KMSKeyArn are all surfaced wherever a function's+ // configuration is serialized (LambdaController:625-637) but were dropped by the+ // hand-enumerated field copy the same way the code location was, before that copy was+ // extended to include them.+ //+ // Verified through ListVersionsByFunction rather than GetFunction/GetFunctionConfiguration+ // with a :1 qualifier: those two both resolve through LambdaService.getFunction(region,+ // functionName), which hardcodes "$LATEST" in its storage lookup and never reads the+ // qualifier at all (LambdaFunctionStore.get(region, functionName) -> get(..., "$LATEST")),+ // so they cannot distinguish version 1's stored config from $LATEST's. That is a separate,+ // pre-existing gap, tracked apart from this fix. ListVersionsByFunction is genuinely+ // version-aware: it serializes each stored version object directly.+ String fnName = "version-config-snapshot";+ given()+ .contentType("application/json")+ .body(String.format("""+ {+ "FunctionName": "%s",+ "Runtime": "nodejs20.x",+ "Role": "arn:aws:iam::000000000000:role/lambda-role",+ "Handler": "index.handler",+ "TracingConfig": {"Mode": "Active"},+ "DeadLetterConfig": {"TargetArn": "arn:aws:sqs:us-east-1:000000000000:dlq"},+ "KMSKeyArn": "arn:aws:kms:us-east-1:000000000000:key/test-key"+ }+ """, fnName))+ .when()+ .post(BASE_PATH + "/functions")+ .then()+ .statusCode(201);++ try {+ given()+ .contentType("application/json")+ .body("{}")+ .when()+ .post(BASE_PATH + "/functions/" + fnName + "/versions")+ .then()+ .statusCode(201)+ .body("Version", equalTo("1"));++ given()+ .when()+ .get(BASE_PATH + "/functions/" + fnName + "/versions")+ .then()+ .statusCode(200)+ .body("Versions.find { it.Version == '1' }.TracingConfig.Mode", equalTo("Active"))+ .body("Versions.find { it.Version == '1' }.DeadLetterConfig.TargetArn",+ equalTo("arn:aws:sqs:us-east-1:000000000000:dlq"))+ .body("Versions.find { it.Version == '1' }.KMSKeyArn",+ equalTo("arn:aws:kms:us-east-1:000000000000:key/test-key"));+ } finally {+ given().delete(BASE_PATH + "/functions/" + fnName);+ }+ }++ private void createInvocableFunction(String fnName) throws Exception {+ ByteArrayOutputStream baos = new ByteArrayOutputStream();+ try (ZipOutputStream zos = new ZipOutputStream(baos)) {+ zos.putNextEntry(new ZipEntry("index.js"));+ zos.write("exports.handler = async () => ({ ok: true });".getBytes());+ zos.closeEntry();+ }+ String base64Zip = Base64.getEncoder().encodeToString(baos.toByteArray());++ given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "Runtime": "nodejs20.x",+ "Role": "arn:aws:iam::000000000000:role/lambda-role",+ "Handler": "index.handler",+ "Timeout": 5,+ "Code": {+ "ZipFile": "%s"+ }+ }+ """.formatted(fnName, base64Zip))+ .when()+ .post(BASE_PATH + "/functions")+ .then()+ .statusCode(201);+ }}