Light, fluffy, and always free - The AWS Local Emulator alternative
fix(lambda): replace the extracted package instead of merging into it (#2672)
Davide4c690351f72
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 40b566d7aa..7bcf16987b 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@@ -6,15 +6,19 @@ import org.jboss.logging.Logger;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;+import java.nio.file.AtomicMoveNotSupportedException;import java.nio.file.Files;import java.nio.file.Path;+import java.nio.file.StandardCopyOption;+import java.util.Comparator;+import java.util.UUID;import java.util.zip.CRC32;import java.util.zip.ZipEntry;import java.util.zip.ZipException;import java.util.zip.ZipFile;/**- * Extracts ZIP bytes to a target directory.+ * Extracts ZIP bytes to a target directory, replacing whatever was there before.* Guards against path traversal attacks by validating entry names.*/@ApplicationScoped@@ -27,7 +31,17 @@ public class ZipExtractor {public void extractTo(byte[] zipBytes, Path targetDir) throws IOException {// Resolve to absolute path so that normalize() on entry paths stays comparablePath absTarget = targetDir.toAbsolutePath().normalize();- Files.createDirectories(absTarget);+ Files.createDirectories(absTarget.getParent());++ // Extract into a staging directory and swap it in, rather than writing over the target+ // in place. A deployment package is the complete contents of the function, so a file+ // dropped between two deploys has to disappear — writing in place only ever adds and+ // overwrites, leaving removed files behind to stay loadable (issue #2647). Staging also+ // makes extraction all-or-nothing: a failure part-way through leaves the previous+ // deployment intact instead of a half-replaced mixture of the two.+ Path staging = absTarget.resolveSibling(+ absTarget.getFileName() + ".floci-staging-" + UUID.randomUUID());+ Files.createDirectories(staging);// Read the archive through its central directory (ZipFile) rather than sequentially// over the local file headers (ZipInputStream). A streaming packager cannot seek back@@ -71,8 +85,8 @@ public class ZipExtractor {continue;}- Path targetPath = absTarget.resolve(entryName).normalize();- if (!targetPath.startsWith(absTarget)) {+ Path targetPath = staging.resolve(entryName).normalize();+ if (!targetPath.startsWith(staging)) {LOG.warnv("Skipping out-of-bounds ZIP entry: {0}", entryName);continue;}@@ -85,13 +99,98 @@ public class ZipExtractor {}}}+ // Extraction succeeded in full: install the new tree.+ install(staging, absTarget);} finally {Files.deleteIfExists(staged);+ // A no-op once install() moved it; on failure this discards the partial staging tree+ // and leaves the previous extraction untouched.+ deleteRecursively(staging);}LOG.debugv("Extracted ZIP to: {0}", absTarget);}+ /**+ * Installs the freshly extracted tree at {@code absTarget}, keeping the package already there+ * until the new one is in place.+ *+ * <p>The old tree is renamed aside and deleted only after the new one lands, rather than+ * deleted up front. Deleting first means a failure in the move leaves the function with no+ * code at all and nothing to restore, turning a failed update into a destroyed deployment.+ * Every failure path here ends with one complete package on disk.+ *+ * <p>Both steps are renames within one directory, so the interval in which the target is+ * absent is two metadata operations rather than a recursive delete followed by a move. It is+ * not zero: POSIX cannot atomically exchange two directories, so a launch landing exactly+ * between the renames can still observe a missing code path. Closing that window entirely+ * needs a lock shared with the launcher, which is wider than this change.+ *+ * <p>Package-private so the failure path can be exercised directly; it is not reachable+ * otherwise, because a move between siblings only fails under conditions a test cannot+ * arrange through {@link #extractTo}.+ */+ static void install(Path staging, Path absTarget) throws IOException {+ Path previous = null;+ if (Files.exists(absTarget)) {+ previous = absTarget.resolveSibling(+ absTarget.getFileName() + ".floci-previous-" + UUID.randomUUID());+ moveIntoPlace(absTarget, previous);+ }+ try {+ moveIntoPlace(staging, absTarget);+ } catch (IOException e) {+ if (previous != null) {+ try {+ // Put the working package back before giving up.+ moveIntoPlace(previous, absTarget);+ } catch (IOException restoreFailed) {+ // Both renames failed, so the function has no code at the canonical path and+ // the working package is sitting under a generated name nobody will look for.+ // Keep the original failure as the one thrown, attach this one, and say+ // exactly where the package went so it can be put back by hand.+ e.addSuppressed(restoreFailed);+ LOG.errorv("Could not restore the previous deployment at {0}. The working "+ + "package is stranded at {1}; move it back to recover.",+ absTarget, previous);+ }+ }+ throw e;+ }+ if (previous != null) {+ // Best effort from here. The new package is already live, so failing to drop the+ // superseded tree must not be reported as a failed deployment: the caller would skip+ // its metadata and warm pool updates while the new code is already serving. Leaving+ // the tree behind costs disk and is recoverable; lying about the outcome is not.+ try {+ deleteRecursively(previous);+ } catch (IOException e) {+ LOG.warnv("Installed {0} but could not remove the superseded package at {1}: {2}",+ absTarget, previous, e.getMessage());+ }+ }+ }++ private static void moveIntoPlace(Path source, Path destination) throws IOException {+ try {+ Files.move(source, destination, StandardCopyOption.ATOMIC_MOVE);+ } catch (AtomicMoveNotSupportedException e) {+ // Some filesystems (and bind mounts inside containers) cannot rename atomically.+ Files.move(source, destination);+ }+ }++ private static void deleteRecursively(Path root) throws IOException {+ if (!Files.exists(root)) {+ return;+ }+ try (var paths = Files.walk(root)) {+ for (Path p : paths.sorted(Comparator.reverseOrder()).toList()) {+ Files.deleteIfExists(p);+ }+ }+ }+/*** Copies one entry to disk, checking it against the CRC recorded for it in the archive.* ZipInputStream verified this on its own; ZipFile does not, so without an explicit checkdiff --git a/src/test/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractorTest.java b/src/test/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractorTest.javaindex ee962241a8..1ba5187c91 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambda/zip/ZipExtractorTest.java@@ -8,6 +8,7 @@ import java.io.IOException;import java.nio.charset.StandardCharsets;import java.nio.file.Files;import java.nio.file.Path;+import java.nio.file.attribute.PosixFilePermissions;import java.util.ArrayList;import java.util.List;import java.util.zip.CRC32;@@ -267,25 +268,62 @@ class ZipExtractorTest {}@Test- void leavesNoStagedArchiveInTheCodeStore(@TempDir Path codeStore) throws IOException {- // ZipFile needs a seekable file, so the archive is staged on disk next to the target- // rather than in the shared java.io.tmpdir. That puts a stray file one level above the- // function's code directory, so pin that none survives: a leaked staging archive would- // sit in the code store indefinitely, and one leaked *inside* a function directory- // would be tar-copied into that function's container at launch.+ void replacesThePreviousExtractionInsteadOfOverlayingIt(@TempDir Path target) throws IOException {+ // Issue #2647: a deployment package is the complete contents of the function, so a file+ // present in one deploy and absent from the next has to disappear. Extracting in place+ // only ever adds and overwrites, so removed files survived and stayed loadable — a+ // handler pointing at a deleted module kept resolving and running stale code.+ byte[] v1 = zipWith("index.js", "v1");+ extractor.extractTo(v1, target);+ Files.writeString(target.resolve("removed.js"), "STALE");+ Files.createDirectories(target.resolve("legacy"));+ Files.writeString(target.resolve("legacy").resolve("old.js"), "STALE");++ byte[] v2 = zipWith("index.js", "v2");+ extractor.extractTo(v2, target);++ assertEquals("v2", Files.readString(target.resolve("index.js")), "new package must land");+ assertFalse(Files.exists(target.resolve("removed.js")),+ "a file absent from the new package must not survive the deploy");+ assertFalse(Files.exists(target.resolve("legacy")),+ "a directory absent from the new package must not survive the deploy");+ }++ @Test+ void leavesThePreviousExtractionIntactWhenExtractionFailsPartWay(@TempDir Path target) throws IOException {+ // Extraction is all-or-nothing: a failure must not leave the function holding a mixture+ // of the old package and part of the new one. The archive below opens cleanly and only+ // fails once its entry has been streamed out, which is exactly when writing directly+ // into the target would already have clobbered the previous deploy.+ extractor.extractTo(zipWith("index.js", "v1"), target);++ byte[] corrupt = corruptedPayloadZip("index.js", "v2-but-corrupted-in-transit");+ assertThrows(IOException.class, () -> extractor.extractTo(corrupt, target));++ assertEquals("v1", Files.readString(target.resolve("index.js")),+ "a failed deploy must leave the previous package in place");+ }++ @Test+ void leavesNoStagingArtefactsInTheCodeStore(@TempDir Path codeStore) throws IOException {+ // Extraction stages two things beside the target rather than in java.io.tmpdir: the+ // archive itself (so ZipFile has a seekable source) and the directory it unpacks into+ // before the swap. Both sit one level above the function's code directory, so pin that+ // neither survives — an orphan would accumulate one per deploy, and anything leaked+ // *inside* a function directory would be tar-copied into its container at launch.Path target = codeStore.resolve("fn");extractor.extractTo(zipWith("index.js", "v1"), target);- assertNoStagedFiles(codeStore);+ assertNoStagingArtefacts(codeStore);byte[] corrupt = corruptedPayloadZip("index.js", "v2-but-corrupted-in-transit");assertThrows(IOException.class, () -> extractor.extractTo(corrupt, target));- assertNoStagedFiles(codeStore);+ assertNoStagingArtefacts(codeStore);}- private static void assertNoStagedFiles(Path codeStore) throws IOException {+ private static void assertNoStagingArtefacts(Path codeStore) throws IOException {try (var entries = Files.list(codeStore)) {assertEquals(List.of("fn"), entries.map(p -> p.getFileName().toString()).sorted().toList(),- "no staged archive may survive extraction, successful or failed");+ "no staged archive or staging directory may survive extraction, successful or failed");}}@@ -356,4 +394,78 @@ class ZipExtractorTest {le16(out, 0);return out.toByteArray();}++ @Test+ void aFailedInstallPutsThePreviousPackageBack(@TempDir Path codeStore) throws IOException {+ // The install used to delete the live tree and then move the new one in, so a failure in+ // the move left the function with no code and nothing to restore: a failed update+ // destroyed a working deployment. Driving install() directly is the only way to reach+ // that branch, since a rename between siblings does not fail under any condition a test+ // can arrange through extractTo.+ Path target = Files.createDirectories(codeStore.resolve("fn"));+ Files.writeString(target.resolve("index.js"), "v1");+ Path staging = codeStore.resolve("fn.floci-staging-never-created");++ assertThrows(IOException.class, () -> ZipExtractor.install(staging, target));++ assertTrue(Files.isRegularFile(target.resolve("index.js")),+ "a failed install must put the previous package back, not leave the function empty");+ assertEquals("v1", Files.readString(target.resolve("index.js")));+ try (var entries = Files.list(codeStore)) {+ assertEquals(List.of("fn"), entries.map(p -> p.getFileName().toString()).sorted().toList(),+ "the restored package must not leave a renamed copy behind");+ }+ }++ @Test+ void aSuccessfulInstallReplacesAndLeavesNoCopyBehind(@TempDir Path codeStore) throws IOException {+ Path target = Files.createDirectories(codeStore.resolve("fn"));+ Files.writeString(target.resolve("index.js"), "v1");+ Files.writeString(target.resolve("removed.js"), "STALE");+ Path staging = Files.createDirectories(codeStore.resolve("fn.floci-staging-x"));+ Files.writeString(staging.resolve("index.js"), "v2");++ ZipExtractor.install(staging, target);++ assertEquals("v2", Files.readString(target.resolve("index.js")));+ assertFalse(Files.exists(target.resolve("removed.js")), "install must replace, not merge");+ try (var entries = Files.list(codeStore)) {+ assertEquals(List.of("fn"), entries.map(p -> p.getFileName().toString()).sorted().toList(),+ "neither the staging tree nor the superseded package may survive");+ }+ }++ @Test+ void aFailureToDropTheSupersededPackageDoesNotFailTheDeployment(@TempDir Path codeStore)+ throws IOException {+ // Once the new tree is installed the deployment has happened. Reporting failure because+ // the superseded copy could not be deleted would make the caller skip its metadata and+ // warm pool updates while the new code is already serving, which is worse than leaving a+ // directory behind. Deletion is blocked by removing write permission on a subdirectory,+ // so its contents cannot be unlinked.+ Path target = Files.createDirectories(codeStore.resolve("fn"));+ Files.writeString(target.resolve("index.js"), "v1");+ Path locked = Files.createDirectories(target.resolve("locked"));+ Files.writeString(locked.resolve("held.txt"), "cannot be removed");+ Files.setPosixFilePermissions(locked, PosixFilePermissions.fromString("r-xr-xr-x"));++ Path staging = Files.createDirectories(codeStore.resolve("fn.floci-staging-x"));+ Files.writeString(staging.resolve("index.js"), "v2");++ try {+ ZipExtractor.install(staging, target);++ assertEquals("v2", Files.readString(target.resolve("index.js")),+ "the new package must be installed even though the old one could not be removed");+ } finally {+ try (var stream = Files.list(codeStore)) {+ for (Path p : stream.toList()) {+ Path stuck = p.resolve("locked");+ if (Files.isDirectory(stuck)) {+ Files.setPosixFilePermissions(stuck, PosixFilePermissions.fromString("rwxr-xr-x"));+ }+ }+ }+ }+ }}