Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): preserve immutable deployment snapshots (#5818)
Andre Kuraitae7e6d12405e
diff --git a/docs/services/lambda.md b/docs/services/lambda.mdindex f6d5692c82..0f66bcd99b 100644--- a/docs/services/lambda.md+++ b/docs/services/lambda.md@@ -243,7 +243,8 @@ Not emulated yet:## Hot-Reloading via Reactive S3 Sync-Floci supports an automatic hot-reloading mechanism when functions are deployed via S3. This follows the standard AWS behavior where S3 and Lambda interact, but is optimized for a seamless local development experience.+Floci supports automatic hot reload for S3 deployments as a local development convenience.+AWS normally copies the deployment package: overwriting its S3 object alone does not redeploy the function.When a Lambda function is created using an S3 bucket and key, Floci maintains a link between the function and its source object. Any subsequent update to that S3 object (e.g., via `s3:PutObject`) automatically triggers a reactive synchronization:@@ -254,6 +255,9 @@ When a Lambda function is created using an S3 bucket and key, Floci maintains aThis allows you to update your Lambda code by simply re-uploading your ZIP to S3, without having to manually call `UpdateFunctionCode` or restart any containers.+Published versions retain their own code snapshots. Reactive sync updates only `$LATEST`;+publication and extraction share the per-function lock so a version cannot capture a partial update.+### Example```bash@@ -273,8 +277,8 @@ aws s3 cp updated-function.zip s3://my-bucket/function.zipaws lambda invoke --function-name my-function out.json```-!!! note "Standard Behavior"- This mechanism requires no custom configuration or non-standard magic strings. It works with standard AWS SDKs and CLI tools, providing a "live" development feel while staying within the AWS API contract.+!!! note "Local development behavior"+ This mechanism requires no custom configuration or special strings. It uses standard AWS SDK and CLI calls; automatic redeployment after an S3 upload is a Floci convenience.## Hot-Reload via Bind Mountdiff --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 5c99f84044..da1cea2ebe 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@@ -765,9 +765,9 @@ public class LambdaService implements ResourceProvider {requireMatchingRevisionId(fn, request);if (zipFileBase64 != null) {+ extractZipCode(fn, zipFileBase64, region);fn.setS3Bucket(null);fn.setS3Key(null);- extractZipCode(fn, zipFileBase64, region);}if (imageUri != null) {fn.setImageUri(imageUri);@@ -2292,14 +2292,7 @@ public class LambdaService implements ResourceProvider {.max(java.util.Comparator.comparingLong(v -> Long.parseLong(v.getVersion())));}- /**- * Copies the function's current code into a directory belonging to this version, falling back- * to {@code $LATEST}'s path if there is nothing to copy or the copy fails.- *- * <p>A copy failure must not fail the publish: the version is still a correct snapshot of the- * configuration, and falling back leaves it exactly as good as every version published before- * this existed, rather than turning a working call into an error.- */+ /** Publishes an owned code snapshot; a failed copy must not reference mutable {@code $LATEST}. */private String versionCodePath(String region, LambdaFunction fn, String version) {String current = fn.getCodeLocalPath();if (current == null || fn.getHotReloadHostPath() != null) {@@ -2308,12 +2301,14 @@ public class LambdaService implements ResourceProvider {try {Path copied = codeStore.copyForVersion(ownerAccount(fn), region, fn.getFunctionName(), version, Path.of(current));- return copied == null ? current : copied.toAbsolutePath().normalize().toString();+ if (copied == null) {+ throw new IOException("Code directory is missing: " + current);+ }+ return copied.toAbsolutePath().normalize().toString();} catch (IOException e) {- LOG.warnv("Could not give version {0} of {1} its own code directory, "- + "falling back to the shared one: {2}",- version, fn.getFunctionName(), e.getMessage());- return current;+ throw new AwsException("ServiceException",+ "Could not create a code snapshot for version " + version + " of "+ + fn.getFunctionName() + ": " + e.getMessage(), 500);}}@@ -2323,10 +2318,9 @@ public class LambdaService implements ResourceProvider {if (current == null && legacyCounterKey != null) {// Counters persisted before the key carried the owning account. Starting over// from 0 here would re-issue a version number that already names a snapshot.- current = versionCounters.remove(legacyCounterKey);+ current = versionCounters.get(legacyCounterKey);}int next = (current != null ? current : 0) + 1;- versionCounters.put(counterKey, next);return next;}}@@ -2398,8 +2392,10 @@ public class LambdaService implements ResourceProvider {+ "returning it rather than creating a duplicate", functionName, unchanged.getVersion());return unchanged;}- int version = nextVersionNumber(versionCounterKey(region, fn),- legacyVersionCounterKey(region, functionName));+ String counterKey = versionCounterKey(region, fn);+ String legacyCounterKey = legacyVersionCounterKey(region, functionName);+ boolean migrateLegacyCounter = !versionCounters.containsKey(counterKey);+ int version = nextVersionNumber(counterKey, legacyCounterKey);LambdaFunction snapshot = new LambdaFunction();snapshot.setAccountId(fn.getAccountId());snapshot.setFunctionName(fn.getFunctionName());@@ -2460,6 +2456,10 @@ public class LambdaService implements ResourceProvider {snapshot.setDurableKmsKeyArn(fn.getDurableKmsKeyArn());functionStore.save(region, snapshot);+ versionCounters.put(counterKey, version);+ if (migrateLegacyCounter) {+ versionCounters.remove(legacyCounterKey);+ }LOG.infov("Published version {0} for function {1}", version, functionName);return snapshot;}@@ -3405,25 +3405,24 @@ public class LambdaService implements ResourceProvider {private void extractZipCodeBytes(LambdaFunction fn, byte[] zipBytes, String region) {Path codePath = codeStore.getCodePath(ownerAccount(fn), region, fn.getFunctionName());try {- zipExtractor.extractTo(zipBytes, codePath, configuredZipMaxEntries());+ zipExtractor.extractTo(zipBytes, codePath, configuredZipMaxEntries(),+ () -> storeDeploymentPackage(fn, zipBytes, region));// Publish the new code identity under the same per-function lock publishVersion holds.// PublishVersion's CodeSha256 precondition is a check-then-act: it compares the hash and// then snapshots the code. Mutating these fields without the lock lets an overlapping// deploy move $LATEST between those two steps, so a version would carry code whose hash- // the caller never authorised even though the check passed. Extraction to disk stays- // outside the lock; only the fields that decide what a snapshot copies are inside it.+ // the caller never authorised even though the check passed. UpdateFunctionCode and reactive+ // sync hold this monitor across extraction; a new function is saved after extraction.String newSha256 = Base64.getEncoder().encodeToString(Digests.sha256(zipBytes));synchronized (lockForConcurrencyOp(fn.getFunctionArn())) {fn.setCodeLocalPath(codePath.toAbsolutePath().normalize().toString());+ fn.setHotReloadHostPath(null);fn.setCodeSizeBytes(zipBytes.length);if (newSha256 != null) {fn.setCodeSha256(newSha256);}}- // Deploy succeeded: keep the exact package so GetFunction can serve- // a real Code.Location.- storeDeploymentPackage(fn, zipBytes, region);// Reclaim a directory left behind by a function created before account-scoping;// codePath above is already the new location, so this is a no-op once migrated.// Locked against publishVersion (see its own comment) so a version cannot be@@ -3507,8 +3506,6 @@ public class LambdaService implements ResourceProvider {throw new AwsException("ServiceUnavailableException", "S3 service not available", 503);}- fn.setS3Bucket(s3Bucket);- fn.setS3Key(s3Key);S3Object obj;try {obj = s3Service.getObject(s3Bucket, s3Key);@@ -3517,6 +3514,8 @@ public class LambdaService implements ResourceProvider {"Unable to fetch code from s3://" + s3Bucket + "/" + s3Key + ": " + e.getMessage(), 400);}extractZipCodeBytes(fn, obj.getData(), region);+ fn.setS3Bucket(s3Bucket);+ fn.setS3Key(s3Key);}private void applyHotReload(LambdaFunction fn, String hostPath) {@@ -4106,23 +4105,28 @@ public class LambdaService implements ResourceProvider {String region = regionResolver.getDefaultRegion();List<LambdaFunction> functions = functionStore.listAllAccounts(region);for (LambdaFunction fn : functions) {- if (fn.isHotReload()) {+ if (!event.bucketName().equals(fn.getS3Bucket()) || !event.key().equals(fn.getS3Key())) {continue;}- if (event.bucketName().equals(fn.getS3Bucket()) && event.key().equals(fn.getS3Key())) {- LOG.infov("Reactive S3 Sync: updating function {0} from s3://{1}/{2}",- fn.getFunctionName(), event.bucketName(), event.key());- try {- S3Object obj = s3Service.getObject(event.bucketName(), event.key());- extractZipCodeBytes(fn, obj.getData(), region);- fn.setLastModified(Instant.now().toEpochMilli());- fn.setRevisionId(UUID.randomUUID().toString());- functionStore.saveForAccount(ownerAccount(fn), region, fn);-- // Push to warm workers- warmPool.pushCodeUpdate(fn);- } catch (Exception e) {- LOG.warnv("Failed reactive sync for function {0}: {1}", fn.getFunctionName(), e.getMessage());+ synchronized (lockForConcurrencyOp(fn.getFunctionArn())) {+ if (fn.isHotReload()) {+ continue;+ }+ if (event.bucketName().equals(fn.getS3Bucket()) && event.key().equals(fn.getS3Key())) {+ LOG.infov("Reactive S3 Sync: updating function {0} from s3://{1}/{2}",+ fn.getFunctionName(), event.bucketName(), event.key());+ try {+ S3Object obj = s3Service.getObject(event.bucketName(), event.key());+ extractZipCodeBytes(fn, obj.getData(), region);+ fn.setLastModified(Instant.now().toEpochMilli());+ fn.setRevisionId(UUID.randomUUID().toString());+ functionStore.saveForAccount(ownerAccount(fn), region, fn);++ // Push to warm workers+ warmPool.pushCodeUpdate(fn);+ } catch (Exception e) {+ LOG.warnv("Failed reactive sync for function {0}: {1}", fn.getFunctionName(), e.getMessage());+ }}}}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/zip/CodeStore.java b/src/main/java/io/github/hectorvent/floci/services/lambda/zip/CodeStore.javaindex 616cac3a49..9917998150 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/zip/CodeStore.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/zip/CodeStore.java@@ -6,6 +6,7 @@ import jakarta.inject.Inject;import org.jboss.logging.Logger;import java.io.IOException;+import java.io.UncheckedIOException;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.StandardCopyOption;@@ -112,6 +113,12 @@ public class CodeStore {Files.copy(from, to, StandardCopyOption.REPLACE_EXISTING);}}+ } catch (UncheckedIOException e) {+ deleteDirectory(target, functionName);+ throw e.getCause();+ } catch (IOException e) {+ deleteDirectory(target, functionName);+ throw e;}return target;}@@ -159,7 +166,7 @@ public class CodeStore {}});LOG.debugv("Deleted code for function: {0}", functionName);- } catch (IOException e) {+ } catch (IOException | UncheckedIOException e) {LOG.warnv("Failed to delete code directory for {0}: {1}", functionName, e.getMessage());}}diff --git a/src/main/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractor.java b/src/main/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractor.javaindex 90e5398289..b79c1dd9c6 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractor.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractor.java@@ -40,6 +40,10 @@ public class ZipExtractor {}public void extractTo(byte[] zipBytes, Path targetDir, int maxEntries) throws IOException {+ extractTo(zipBytes, targetDir, maxEntries, null);+ }++ public void extractTo(byte[] zipBytes, Path targetDir, int maxEntries, Runnable beforeInstall) throws IOException {if (maxEntries < 1) {throw new IOException("ZIP archive entry limit must be at least 1: " + maxEntries);}@@ -142,6 +146,9 @@ public class ZipExtractor {}}// Extraction succeeded in full: install the new tree.+ if (beforeInstall != null) {+ beforeInstall.run();+ }install(staging, absTarget);} finally {Files.deleteIfExists(staged);diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaS3DeploymentIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaS3DeploymentIntegrationTest.javanew file mode 100644index 0000000000..96bb626fea--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaS3DeploymentIntegrationTest.java@@ -0,0 +1,66 @@+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.Map;+import java.util.UUID;+import java.util.zip.ZipEntry;+import java.util.zip.ZipOutputStream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;++@QuarkusTest+class LambdaS3DeploymentIntegrationTest {++ @Test+ void reactiveS3SyncPreservesPublishedVersions() throws Exception {+ String name = "s3-deployment-" + UUID.randomUUID().toString().substring(0, 8);+ String key = "function.zip";+ String functionPath = "/2015-03-31/functions/" + name;+ given().when().put("/" + name).then().statusCode(200);+ try {+ given().body(makeZip("v1")).when().put("/" + name + "/" + key).then().statusCode(200);+ String codeHash = given().contentType("application/json").body(Map.of(+ "FunctionName", name, "Runtime", "nodejs20.x",+ "Role", "arn:aws:iam::000000000000:role/role",+ "Handler", "index.handler", "Timeout", 30,+ "Code", Map.of("S3Bucket", name, "S3Key", key)))+ .when().post("/2015-03-31/functions").then().statusCode(201)+ .extract().path("CodeSha256");+ try {+ String version = given().contentType("application/json").body("{}")+ .when().post(functionPath + "/versions").then().statusCode(201)+ .body("CodeSha256", equalTo(codeHash)).extract().path("Version");+ given().body("{}").when().post(functionPath + "/invocations")+ .then().statusCode(200).body("body", equalTo("v1"));++ given().body(makeZip("v2")).when().put("/" + name + "/" + key).then().statusCode(200);+ given().body("{}").when().post(functionPath + "/invocations")+ .then().statusCode(200).body("body", equalTo("v2"));+ given().queryParam("Qualifier", version).body("{}")+ .when().post(functionPath + "/invocations")+ .then().statusCode(200).body("body", equalTo("v1"));+ } finally {+ given().when().delete(functionPath).then().statusCode(204);+ }+ } finally {+ given().when().delete("/" + name + "/" + key).then().statusCode(204);+ given().when().delete("/" + name).then().statusCode(204);+ }+ }++ private static byte[] makeZip(String body) throws Exception {+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();+ try (ZipOutputStream zip = new ZipOutputStream(bytes)) {+ zip.putNextEntry(new ZipEntry("index.js"));+ zip.write(("exports.handler = async () => ({ body: '" + body + "' });")+ .getBytes(StandardCharsets.UTF_8));+ zip.closeEntry();+ }+ return bytes.toByteArray();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.javaindex e158a2fc9f..744fbbb824 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/LambdaServiceTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.lambda;+import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;@@ -12,6 +13,9 @@ import io.github.hectorvent.floci.services.lambda.model.LambdaFunction;import io.github.hectorvent.floci.services.lambda.model.LambdaUrlConfig;import io.github.hectorvent.floci.services.lambda.zip.CodeStore;import io.github.hectorvent.floci.services.lambda.zip.ZipExtractor;+import io.github.hectorvent.floci.services.s3.S3Service;+import io.github.hectorvent.floci.services.s3.model.S3Object;+import io.github.hectorvent.floci.services.s3.model.S3ObjectUpdatedEvent;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.junit.jupiter.params.ParameterizedTest;@@ -29,13 +33,19 @@ import java.util.List;import java.util.Map;import java.util.Optional;import java.util.Set;+import java.util.UUID;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicReference;+import java.util.stream.Collectors;+import java.util.stream.Stream;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;+import static io.github.hectorvent.floci.testing.ThreadStates.awaitBlockedOrDone;import static org.junit.jupiter.api.Assertions.*;import static org.mockito.Mockito.*;@@ -974,6 +984,11 @@ class LambdaServiceTest {private LambdaService serviceWithHotReload(boolean enabled, List<String> allowedPaths,int zipMaxEntries) {+ return serviceWithHotReload(enabled, allowedPaths, zipMaxEntries, "docker");+ }++ private LambdaService serviceWithHotReload(boolean enabled, List<String> allowedPaths,+ int zipMaxEntries, String executor) {EmulatorConfig cfg = mock(EmulatorConfig.class);EmulatorConfig.ServicesConfig svc = mock(EmulatorConfig.ServicesConfig.class);EmulatorConfig.LambdaServiceConfig lambdaCfg = mock(EmulatorConfig.LambdaServiceConfig.class);@@ -985,6 +1000,7 @@ class LambdaServiceTest {when(lambdaCfg.defaultTimeoutSeconds()).thenReturn(3);when(lambdaCfg.defaultMemoryMb()).thenReturn(128);when(lambdaCfg.zipMaxEntries()).thenReturn(zipMaxEntries);+ when(lambdaCfg.executor()).thenReturn(executor);when(hr.enabled()).thenReturn(enabled);when(hr.allowedPaths()).thenReturn(allowedPaths == null ? Optional.empty() : Optional.of(allowedPaths));@@ -1205,8 +1221,7 @@ class LambdaServiceTest {@Testvoid hotReload_convertFromS3Backed_clearsBucketAndKey() {- // A function previously deployed from S3 that is later converted to hot-reload- // must have s3Bucket/s3Key cleared so the reactive S3 sync observer cannot fire.+ // Clear the previous S3 location so reactive sync cannot overwrite the bind-mounted code.LambdaService svc = serviceWithHotReload(true, null);Map<String, Object> req = baseRequest("hr-convert");req.put("Code", Map.of("S3Bucket", "my-code-bucket", "S3Key", "fn.zip"));@@ -1225,6 +1240,79 @@ class LambdaServiceTest {assertEquals("/tmp/converted", updated.getHotReloadHostPath());}+ @Test+ void requiredPackageStorageFailurePreservesHotReloadState() {+ LambdaService svc = serviceWithHotReload(true, null, ZipExtractor.DEFAULT_MAX_ENTRIES, "kubernetes");+ String name = "hot-reload-storage-failure";+ Map<String, Object> request = baseRequest(name);+ request.put("Code", Map.of("S3Bucket", "hot-reload", "S3Key", "/tmp/host-code"));+ LambdaFunction original = svc.createFunction(REGION, request);+ String revision = original.getRevisionId();+ long modified = original.getLastModified();++ AwsException failure = assertThrows(AwsException.class,+ () -> svc.updateFunctionCode(REGION, name, Map.of("ZipFile", zipWithBody("new"))));++ assertEquals("ServiceException", failure.getErrorCode());+ LambdaFunction unchanged = svc.getFunction(REGION, name);+ assertTrue(unchanged.isHotReload());+ assertEquals("/tmp/host-code", unchanged.getHotReloadHostPath());+ assertNull(unchanged.getCodeLocalPath());+ assertEquals(revision, unchanged.getRevisionId());+ assertEquals(modified, unchanged.getLastModified());+ assertEquals("", unchanged.getCodeSha256());+ }++ @Test+ void hotReload_zipDeploymentConvertsToManagedCodeAndPreservesPublishedVersions() throws Exception {+ LambdaService svc = serviceWithHotReload(true, null);+ String name = "hr-managed-deployment";+ Map<String, Object> request = baseRequest(name);+ request.put("Architectures", List.of("x86_64"));+ request.put("Code", Map.of("S3Bucket", "hot-reload", "S3Key", "/tmp/host-code"));+ request.put("Environment", Map.of("Variables", Map.of("MARKER", "configured")));+ LambdaFunction original = svc.createFunction(REGION, request);+ String originalRevision = original.getRevisionId();+ long originalModified = original.getLastModified();++ AwsException failure = assertThrows(AwsException.class, () -> svc.updateFunctionCode(REGION, name,+ Map.of("ZipFile", Base64.getEncoder().encodeToString("not a ZIP".getBytes(StandardCharsets.UTF_8)),+ "Architectures", List.of("arm64"))));++ assertEquals("InvalidParameterValueException", failure.getErrorCode());+ LambdaFunction unchanged = svc.getFunction(REGION, name);+ assertTrue(unchanged.isHotReload());+ assertEquals("/tmp/host-code", unchanged.getHotReloadHostPath());+ assertNull(unchanged.getCodeLocalPath());+ assertEquals("", unchanged.getCodeSha256());+ assertEquals(0L, unchanged.getCodeSizeBytes());+ assertEquals(originalRevision, unchanged.getRevisionId());+ assertEquals(originalModified, unchanged.getLastModified());+ assertEquals(List.of("x86_64"), unchanged.getArchitectures());+ assertEquals(Map.of("MARKER", "configured"), unchanged.getEnvironment());++ LambdaFunction converted = svc.updateFunctionCode(REGION, name, Map.of("ZipFile", zipWithBody("v1")));++ assertFalse(converted.isHotReload());+ assertNull(converted.getHotReloadHostPath());+ Path latestPath = Path.of(converted.getCodeLocalPath());+ assertEquals("v1", Files.readString(latestPath.resolve("index.js")).trim());+ LambdaFunction published = svc.publishVersion(REGION, name, null);+ Path versionPath = Path.of(published.getCodeLocalPath());+ String versionHash = published.getCodeSha256();+ assertFalse(published.isHotReload());+ assertNotEquals(latestPath, versionPath);++ svc.updateFunctionCode(REGION, name, Map.of("ZipFile", zipWithBody("v2")));++ assertEquals("v2", Files.readString(latestPath.resolve("index.js")).trim());+ assertEquals("v1", Files.readString(versionPath.resolve("index.js")).trim());+ assertEquals(versionHash, published.getCodeSha256());+ assertEquals(Map.of("MARKER", "configured"), published.getEnvironment());+ assertEquals(10, published.getTimeout());+ assertEquals(256, published.getMemorySize());+ }+/*** Test helper: a LambdaFunctionStore whose save() throws on demand so* tests can exercise the LambdaService rollback path.@@ -2111,6 +2199,9 @@ class LambdaServiceTest {assertTrue(Files.isDirectory(v1Path), "a published version must have its own code directory");assertEquals("v1", Files.readString(v1Path.resolve("index.js")).trim());+ assertFalse(Files.isSameFile(v1Path.resolve("index.js"),+ Path.of(service.getFunction(REGION, "version-code-isolation-fn").getCodeLocalPath())+ .resolve("index.js")));// Redeploy $LATEST. Extraction replaces its directory wholesale, which is what used to take// the published version's code with it.@@ -2128,6 +2219,8 @@ class LambdaServiceTest {assertTrue(Files.isDirectory(v1Path), "the version's code must survive a redeploy of $LATEST");assertEquals("v1", Files.readString(v1Path.resolve("index.js")).trim());assertEquals(v1Sha, v1.getCodeSha256());+ assertFalse(Files.isSameFile(v1Path.resolve("index.js"),+ Path.of(latest.getCodeLocalPath()).resolve("index.js")));}@Test@@ -2173,6 +2266,190 @@ class LambdaServiceTest {assertTrue(Files.isDirectory(latestPath), "$LATEST's code must be left alone");}+ @Test+ void unrelatedS3EventsDoNotAcquireOtherFunctionsDeploymentLocks() throws Exception {+ LambdaFunction first = service.createFunction(REGION, baseRequest("unrelated-sync-first"));+ LambdaFunction second = service.createFunction(REGION, baseRequest("unrelated-sync-second"));+ first.setS3Bucket("source-bucket");+ first.setS3Key("first.zip");+ second.setS3Bucket("source-bucket");+ second.setS3Key("second.zip");+ ExecutorService worker = Executors.newSingleThreadExecutor();+ try {+ synchronized (service.lockForConcurrencyOp(first.getFunctionArn())) {+ Future<?> deployment = worker.submit(() -> {+ synchronized (service.lockForConcurrencyOp(second.getFunctionArn())) {+ service.onS3ObjectUpdated(new S3ObjectUpdatedEvent("tasks-bucket", "deployment.zip"));+ }+ });+ deployment.get(2, TimeUnit.SECONDS);+ }+ } finally {+ worker.shutdownNow();+ }+ }++ @Test+ void reactiveSyncHoldsThePublicationLockThroughExtraction() throws Exception {+ S3Service s3 = mock(S3Service.class);+ WarmPool warmPool = mock(WarmPool.class);+ ZipExtractor extractor = spy(new ZipExtractor());+ StorageFactory storageFactory = mock(StorageFactory.class);+ when(storageFactory.create(anyString(), anyString(), any()))+ .thenAnswer(inv -> AccountAwareStorageBackend.inMemory("000000000000"));+ LambdaFunctionStore functionStore = new LambdaFunctionStore(new InMemoryStorage<String, LambdaFunction>());+ LambdaAliasStore aliasStore = new LambdaAliasStore(storageFactory);+ LambdaService syncingService = new LambdaService(functionStore, null, new LambdaConcurrencyLimiter(),+ warmPool, new CodeStore(Path.of("target/test-data/lambda-code")), extractor, null,+ new RegionResolver(REGION, "000000000000"), null, aliasStore,+ new LambdaTargetResolver(functionStore, aliasStore), s3, null, null, null, null,+ storageFactory, null, null, null, null, new ObjectMapper());+ String name = "reactive-snapshot-" + UUID.randomUUID();+ when(s3.getObject("code-bucket", "function.zip"))+ .thenReturn(new S3Object("code-bucket", "function.zip",+ Base64.getDecoder().decode(zipWithBody("v1")), "application/zip"))+ .thenReturn(new S3Object("code-bucket", "function.zip",+ Base64.getDecoder().decode(zipWithBody("v2")), "application/zip"));+ Map<String, Object> request = baseRequest(name);+ request.put("Code", Map.of("S3Bucket", "code-bucket", "S3Key", "function.zip"));+ LambdaFunction latest = syncingService.createFunction(REGION, request);+ LambdaFunction first = syncingService.publishVersion(REGION, name, null);+ CountDownLatch extracting = new CountDownLatch(1);+ CountDownLatch release = new CountDownLatch(1);+ doAnswer(inv -> {+ assertTrue(Thread.holdsLock(syncingService.lockForConcurrencyOp(latest.getFunctionArn())));+ extracting.countDown();+ assertTrue(release.await(5, TimeUnit.SECONDS));+ return inv.callRealMethod();+ }).when(extractor).extractTo(any(byte[].class), any(Path.class), anyInt(), any(Runnable.class));+ ExecutorService workers = Executors.newFixedThreadPool(2);+ try {+ Future<?> sync = workers.submit(() -> syncingService.onS3ObjectUpdated(+ new S3ObjectUpdatedEvent("code-bucket", "function.zip")));+ assertTrue(extracting.await(2, TimeUnit.SECONDS));+ AtomicReference<Thread> publicationThread = new AtomicReference<>();+ Future<LambdaFunction> publication = workers.submit(() -> {+ publicationThread.set(Thread.currentThread());+ return syncingService.publishVersion(REGION, name, null);+ });+ awaitBlockedOrDone(publicationThread, publication);+ assertFalse(publication.isDone());+ release.countDown();+ sync.get(5, TimeUnit.SECONDS);+ LambdaFunction second = publication.get(5, TimeUnit.SECONDS);+ assertEquals("v1", Files.readString(Path.of(first.getCodeLocalPath()).resolve("index.js")).trim());+ assertEquals("v2", Files.readString(Path.of(second.getCodeLocalPath()).resolve("index.js")).trim());+ assertEquals(latest.getCodeSha256(), second.getCodeSha256());+ verify(warmPool).pushCodeUpdate(latest);+ } finally {+ release.countDown();+ workers.shutdownNow();+ }+ }++ @Test+ void deletingOneVersionPreservesAnotherVersionAndLatest() throws Exception {+ String name = "shared-version-code";+ Map<String, Object> request = baseRequest(name);+ request.put("Code", Map.of("ZipFile", zipWithBody("shared")));+ LambdaFunction latest = service.createFunction(REGION, request);+ LambdaFunction first = service.publishVersion(REGION, name, null);+ service.updateFunctionConfiguration(REGION, name, Map.of("Timeout", 20));+ LambdaFunction second = service.publishVersion(REGION, name, null);+ Path firstFile = Path.of(first.getCodeLocalPath()).resolve("index.js");+ Path secondFile = Path.of(second.getCodeLocalPath()).resolve("index.js");+ Path latestFile = Path.of(latest.getCodeLocalPath()).resolve("index.js");+ assertFalse(Files.isSameFile(firstFile, secondFile));+ assertFalse(Files.isSameFile(secondFile, latestFile));++ service.deleteFunction(REGION, name, first.getVersion());++ assertFalse(Files.exists(firstFile));+ assertEquals("shared", Files.readString(secondFile).trim());+ assertEquals("shared", Files.readString(latestFile).trim());+ assertEquals(20, second.getTimeout());+ }++ @Test+ void failedVersionSnapshotKeepsLatestVersionsAndAliasesIntact() throws Exception {+ String name = "failed-version-snapshot-" + UUID.randomUUID();+ Map<String, Object> request = baseRequest(name);+ request.put("Code", Map.of("ZipFile", zipWithBody("v1")));+ service.createFunction(REGION, request);+ LambdaFunction first = service.publishVersion(REGION, name, null);+ service.createAlias(REGION, name, "live", first.getVersion(), null, null);+ LambdaFunction latest = service.updateFunctionCode(REGION, name,+ Map.of("ZipFile", zipWithBody("v2")));+ Path latestPath = Path.of(latest.getCodeLocalPath());+ Path firstPath = Path.of(first.getCodeLocalPath());+ Path unreadable = Files.createSymbolicLink(latestPath.resolve("unreadable"),+ Path.of("missing-file"));+ try {+ AwsException failure = assertThrows(AwsException.class,+ () -> service.publishVersion(REGION, name, null));+ assertEquals("ServiceException", failure.getErrorCode());+ assertEquals(Set.of("$LATEST", first.getVersion()),+ service.listVersionsByFunction(REGION, name).stream()+ .map(LambdaFunction::getVersion).collect(Collectors.toSet()));+ assertEquals(first.getVersion(), service.getAlias(REGION, name, "live").getFunctionVersion());+ assertEquals("v1", Files.readString(firstPath.resolve("index.js")).trim());+ assertEquals("v2", Files.readString(latestPath.resolve("index.js")).trim());+ try (Stream<Path> versions = Files.list(firstPath.getParent())) {+ assertEquals(List.of(firstPath), versions.toList(),+ "a failed snapshot must not leave a partial version directory");+ }+ } finally {+ Files.delete(unreadable);+ }+ LambdaFunction retry = service.publishVersion(REGION, name, null);+ assertEquals("2", retry.getVersion(), "failed publication must not consume a version number");+ assertNotEquals(latestPath, Path.of(retry.getCodeLocalPath()));+ assertEquals(latest.getCodeSha256(), retry.getCodeSha256());+ assertEquals("v2", Files.readString(Path.of(retry.getCodeLocalPath()).resolve("index.js")).trim());+ }++ @Test+ void rejectedZipUpdatePreservesLatestCodeVersionsAliasesAndConfiguration() throws Exception {+ String name = "rejected-zip-deployment";+ Map<String, Object> request = baseRequest(name);+ request.put("Architectures", List.of("x86_64"));+ request.put("Code", Map.of("ZipFile", zipWithBody("v1")));+ request.put("Environment", Map.of("Variables", Map.of("MARKER", "original")));+ service.createFunction(REGION, request);+ LambdaFunction version = service.publishVersion(REGION, name, null);+ service.createAlias(REGION, name, "live", version.getVersion(), null, null);+ LambdaFunction latest = service.updateFunctionCode(REGION, name, Map.of("ZipFile", zipWithBody("v2")));+ String latestPath = latest.getCodeLocalPath();+ String latestHash = latest.getCodeSha256();+ long latestSize = latest.getCodeSizeBytes();+ String latestRevision = latest.getRevisionId();+ long latestModified = latest.getLastModified();+ String versionHash = version.getCodeSha256();++ AwsException failure = assertThrows(AwsException.class, () -> service.updateFunctionCode(REGION, name,+ Map.of("ZipFile", Base64.getEncoder().encodeToString("not a ZIP".getBytes(StandardCharsets.UTF_8)),+ "Architectures", List.of("arm64"), "Publish", true)));++ assertEquals("InvalidParameterValueException", failure.getErrorCode());+ LambdaFunction unchanged = service.getFunction(REGION, name);+ assertEquals(latestPath, unchanged.getCodeLocalPath());+ assertEquals("v2", Files.readString(Path.of(latestPath).resolve("index.js")).trim());+ assertEquals(latestHash, unchanged.getCodeSha256());+ assertEquals(latestSize, unchanged.getCodeSizeBytes());+ assertEquals(latestRevision, unchanged.getRevisionId());+ assertEquals(latestModified, unchanged.getLastModified());+ assertNull(unchanged.getHotReloadHostPath());+ assertEquals(List.of("x86_64"), unchanged.getArchitectures());+ assertEquals(Map.of("MARKER", "original"), unchanged.getEnvironment());+ assertEquals(10, unchanged.getTimeout());+ assertEquals(256, unchanged.getMemorySize());+ assertEquals("v1", Files.readString(Path.of(version.getCodeLocalPath()).resolve("index.js")).trim());+ assertEquals(versionHash, version.getCodeSha256());+ assertEquals(version.getVersion(), service.getAlias(REGION, name, "live").getFunctionVersion());+ assertEquals(Set.of("$LATEST", version.getVersion()), service.listVersionsByFunction(REGION, name).stream()+ .map(LambdaFunction::getVersion).collect(Collectors.toSet()));+ }+private static String zipWithBody(String body) throws Exception {ByteArrayOutputStream baos = new ByteArrayOutputStream();try (ZipOutputStream zos = new ZipOutputStream(baos)) {diff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/zip/CodeStoreTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/zip/CodeStoreTest.javaindex 9c7ee1d773..980932a270 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/zip/CodeStoreTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/zip/CodeStoreTest.java@@ -2,10 +2,15 @@ package io.github.hectorvent.floci.services.lambda.zip;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;import java.io.IOException;+import java.nio.file.FileSystem;+import java.nio.file.FileSystems;import java.nio.file.Files;import java.nio.file.Path;+import java.util.Map;import static org.junit.jupiter.api.Assertions.*;@@ -174,6 +179,42 @@ class CodeStoreTest {assertTrue(version.normalize().startsWith(baseDir.normalize()));}+ @Test+ void versionFilesRemainIndependentAfterInPlaceHostEdits(@TempDir Path baseDir)+ throws IOException {+ CodeStore store = new CodeStore(baseDir);+ Path latest = store.getCodePath(ACCOUNT_A, REGION, "fn");+ writeHandler(latest.resolve("lib"), "handler");+ Files.createSymbolicLink(latest.resolve("index.js"), Path.of("lib/index.js"));++ Path version = store.copyForVersion(ACCOUNT_A, REGION, "fn", "1", latest);++ assertFalse(Files.isSameFile(latest.resolve("lib/index.js"), version.resolve("lib/index.js")));+ Files.writeString(latest.resolve("lib/index.js"), "changed in place");+ assertEquals("handler", Files.readString(version.resolve("lib/index.js")));+ assertFalse(Files.isSymbolicLink(version.resolve("index.js")));+ assertFalse(Files.isSameFile(latest.resolve("index.js"), version.resolve("index.js")));+ assertEquals("handler", Files.readString(version.resolve("index.js")));+ }++ @ParameterizedTest+ @CsvSource({"true, false", "false, true", "true, true"})+ void versionCopiesWorkAcrossFilesystemProviders(boolean zipSource, boolean zipTarget, @TempDir Path baseDir)+ throws IOException {+ try (FileSystem zip = FileSystems.newFileSystem(baseDir.resolve("code.zip"), Map.of("create", "true"))) {+ CodeStore store = new CodeStore(zipTarget ? zip.getPath("/code") : baseDir.resolve("code"));+ Path source = zipSource ? zip.getPath("/source") : baseDir.resolve("source");+ writeHandler(source.resolve("lib"), "original");++ Path version = store.copyForVersion(ACCOUNT_A, REGION, "fn", "1", source);+ writeHandler(source.resolve("lib"), "changed");++ assertEquals("original", Files.readString(version.resolve("lib/index.js")));+ store.deleteVersion(ACCOUNT_A, REGION, "fn", "1");+ assertEquals("changed", Files.readString(source.resolve("lib/index.js")));+ }+ }+private void writeHandler(Path codePath, String content) throws IOException {Files.createDirectories(codePath);Files.writeString(codePath.resolve("index.js"), content);