Light, fluffy, and always free - The AWS Local Emulator alternative
feat(lambdaweb): accept code up to 512 MiB and refuse more as AWS does (#6218)
TATSUNO “Taz” Yasuhiro2720f8488442
diff --git a/docs/services/lambda-web-functions.md b/docs/services/lambda-web-functions.mdindex fc67146fe0..9ab91f9006 100644--- a/docs/services/lambda-web-functions.md+++ b/docs/services/lambda-web-functions.md@@ -35,7 +35,7 @@ The `Lambda Web` service model (apiVersion 2025-03-07, `aws lambda-web` in the A## Emulation Behavior- **Instant convergence:** a revision and an endpoint are stored `Active`, or `Failed` as below, and an endpoint update is stored `Successful`. The create and update responses still report the transitional state AWS reports (`Pending`, `updateStatus: InProgress`, and the per-region block as it was before the update), so a waiter sees one poll.-- **Failed revisions:** a revision whose code is not a zip is stored `Failed`, as on AWS. It cannot be deployed: weights that name it, or `LatestRevision` while it is the newest revision, are `409 ConflictException`, and `LatestRevision` endpoints stay on their revision. The endpoint of a `CreateWebFunction` whose revision fails is `Failed` too. It answers every request with `409` and `Platform.EndpointNotActive` and refuses updates until it is deleted. In a stack, the revision's resource fails with the revision's `stateReason` and the rollback deletes it. An empty object is a `500 InternalServerException` with the body `{}`, as on AWS.+- **Failed revisions:** a revision whose code is not a zip, or whose files add up to more than 512 MiB, is stored `Failed`, as on AWS. It cannot be deployed: weights that name it, or `LatestRevision` while it is the newest revision, are `409 ConflictException`, and `LatestRevision` endpoints stay on their revision. The endpoint of a `CreateWebFunction` whose revision fails is `Failed` too. It answers every request with `409` and `Platform.EndpointNotActive` and refuses updates until it is deleted. In a stack, the revision's resource fails with the revision's `stateReason` and the rollback deletes it. An empty object is a `500 InternalServerException` with the body `{}`, and an object over 512 MiB is a `400 ValidationException`, as on AWS.- **Code comes from S3 only.** The object named in `buildConfig.codeConfig.s3Object` must exist in Floci's S3, as on AWS. AWS also requires bucket versioning and a bucket policy for the Lambda service principal. Floci does not check them yet.- **Each revision keeps its own copy of the code**, read at creation from the version the request names or the current one, under the Lambda `code-path`. As on AWS, a later write or delete in the bucket does not change what the revision runs. AWS moves a revision to `Failed` when it later finds its object version gone, which Floci does not do.- **Execution role and network connector** ARNs are checked for shape only. The assume-role check AWS makes is not done yet.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 8037938bda..4e323822c1 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@@ -58,7 +58,7 @@ public class ZipExtractor {Path staged = Files.createTempFile(absTarget.getParent(), ".floci-staging-", ".zip");try {Files.write(staged, zipBytes);- extract(staged, absTarget, maxEntries, beforeInstall);+ extract(staged, absTarget, maxEntries, MAX_ENTRY_BYTES, MAX_EXPANDED_BYTES, beforeInstall);} finally {Files.deleteIfExists(staged);}@@ -73,20 +73,33 @@ public class ZipExtractor {checkLimits(maxEntries, Files.size(zipFile));Path absTarget = targetDir.toAbsolutePath().normalize();Files.createDirectories(absTarget.getParent());- extract(zipFile, absTarget, maxEntries, beforeInstall);+ extract(zipFile, absTarget, maxEntries, MAX_ENTRY_BYTES, MAX_EXPANDED_BYTES, beforeInstall);+ }++ /** For a package whose archive, files and expanded total may each reach {@code maxBytes}. */+ public void extractTo(Path zipFile, Path targetDir, int maxEntries, long maxBytes) throws IOException {+ checkLimits(maxEntries, Files.size(zipFile), maxBytes);+ Path absTarget = targetDir.toAbsolutePath().normalize();+ Files.createDirectories(absTarget.getParent());+ extract(zipFile, absTarget, maxEntries, maxBytes, maxBytes, null);}static void checkLimits(int maxEntries, long compressedBytes) throws IOException {+ checkLimits(maxEntries, compressedBytes, S3_MAX_COMPRESSED_BYTES);+ }++ private static void checkLimits(int maxEntries, long compressedBytes, long maxCompressedBytes) throws IOException {if (maxEntries < 1) {throw new IOException("ZIP archive entry limit must be at least 1: " + maxEntries);}- if (compressedBytes > S3_MAX_COMPRESSED_BYTES) {- throw new IOException("ZIP archive exceeds the " + S3_MAX_COMPRESSED_BYTES+ if (compressedBytes > maxCompressedBytes) {+ throw new IOException("ZIP archive exceeds the " + maxCompressedBytes+ " byte compressed limit: " + compressedBytes);}}- private void extract(Path archive, Path absTarget, int maxEntries, Runnable beforeInstall) throws IOException {+ private void extract(Path archive, Path absTarget, int maxEntries, long maxEntryBytes, long maxExpandedBytes,+ Runnable beforeInstall) throws IOException {// 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@@ -143,13 +156,13 @@ public class ZipExtractor {}long declaredSize = entry.getSize();- if (declaredSize > MAX_ENTRY_BYTES) {- throw new IOException("ZIP entry exceeds the " + MAX_ENTRY_BYTES+ if (declaredSize > maxEntryBytes) {+ throw new IOException("ZIP entry exceeds the " + maxEntryBytes+ " byte limit: " + entryName);}long accountedSize = declaredSize >= 0 ? declaredSize : 0;- if (accountedSize > MAX_EXPANDED_BYTES - expandedBytes) {- throw new IOException("ZIP archive exceeds the " + MAX_EXPANDED_BYTES+ if (accountedSize > maxExpandedBytes - expandedBytes) {+ throw new IOException("ZIP archive exceeds the " + maxExpandedBytes+ " byte expanded limit");}@@ -158,10 +171,10 @@ public class ZipExtractor {} else {Files.createDirectories(targetPath.getParent());long copyLimit = declaredSize >= 0- ? Math.min(declaredSize, MAX_EXPANDED_BYTES - expandedBytes)- : MAX_EXPANDED_BYTES - expandedBytes;+ ? Math.min(declaredSize, maxExpandedBytes - expandedBytes)+ : maxExpandedBytes - expandedBytes;long copiedBytes = copyVerified(zip, entry, targetPath,- MAX_ENTRY_BYTES, copyLimit);+ maxEntryBytes, copyLimit);accountedSize = declaredSize >= 0 ? declaredSize : copiedBytes;}expandedBytes += accountedSize;diff --git a/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebCode.java b/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebCode.javaindex 160686065c..f1268083b3 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebCode.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebCode.java@@ -19,8 +19,10 @@ import java.util.Comparator;import java.util.HashSet;import java.util.List;import java.util.Locale;+import java.util.OptionalLong;import java.util.Set;import java.util.stream.Stream;+import java.util.zip.ZipEntry;import java.util.zip.ZipException;import java.util.zip.ZipFile;@@ -36,6 +38,9 @@ public class LambdaWebCode {/** The {@code @} keeps this tree apart from the Lambda function directories, whose names never have one. */private static final String ROOT = "@web-functions";+ /** AWS refuses a larger object and fails a revision whose files add up to more. */+ static final long MAX_BYTES = 512L * 1024 * 1024;+private final Path baseDir;@Inject@@ -59,17 +64,24 @@ public class LambdaWebCode {}}- boolean opensAsZip(String accountId, String region, String functionName, String revisionId) {- try (ZipFile ignored = new ZipFile(file(accountId, region, functionName, revisionId).toFile())) {- return true;+ /** The unsigned sum of the sizes the zip declares for its files, or empty when the code is not a zip. */+ OptionalLong unzippedSize(String accountId, String region, String functionName, String revisionId) {+ try (ZipFile zip = new ZipFile(file(accountId, region, functionName, revisionId).toFile())) {+ return OptionalLong.of(zip.stream().mapToLong(ZipEntry::getSize).reduce(0, LambdaWebCode::addSaturating));} catch (ZipException e) {- return false;+ return OptionalLong.empty();} catch (IOException e) {deleteRevision(accountId, region, functionName, revisionId);throw new UncheckedIOException("Could not read the code of " + functionName + " revision " + revisionId, e);}}+ /** AWS adds the sizes as unsigned 64-bit numbers and stops at the largest one. */+ private static long addSaturating(long total, long size) {+ long sum = total + size;+ return Long.compareUnsigned(sum, total) < 0 ? -1L : sum;+ }+void deleteRevision(String accountId, String region, String functionName, String revisionId) {try {Files.deleteIfExists(file(accountId, region, functionName, revisionId));diff --git a/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebEnvironmentManager.java b/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebEnvironmentManager.javaindex cfde3c2821..dea4e10696 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebEnvironmentManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebEnvironmentManager.java@@ -690,7 +690,7 @@ public class LambdaWebEnvironmentManager implements ContainerTeardown {throw new UncheckedIOException("Could not make room for the code of " + fn.functionName, e);}try {- zipExtractor.extractTo(zip, dir, config.services().lambda().zipMaxEntries());+ zipExtractor.extractTo(zip, dir, config.services().lambda().zipMaxEntries(), LambdaWebCode.MAX_BYTES);RetryingTarCopier.copyStreamed(lifecycleManager.getDockerClient(), containerId, TASK_DIR,"web-" + fn.functionName, out -> tar(dir, out));} catch (IOException e) {diff --git a/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebService.java b/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebService.javaindex 433c19dbdf..c89ca6fd3d 100644--- a/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebService.java+++ b/src/main/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebService.java@@ -43,6 +43,7 @@ import java.util.List;import java.util.Locale;import java.util.Map;import java.util.Optional;+import java.util.OptionalLong;import java.util.Set;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;@@ -54,10 +55,10 @@ import java.util.regex.Pattern;/*** Control plane of Lambda Web Functions (apiVersion 2025-03-07). A revision is stored Active, or- * Failed when its code is not a zip. An endpoint is stored Active, or Failed when CreateWebFunction- * gives it a Failed revision, and an endpoint update is stored Successful. The create and update- * responses show the transitional state AWS reports. Invocation through an endpoint domain is not- * part of this service.+ * Failed when its code is not a zip or unzips past the size limit. An endpoint is stored Active, or+ * Failed when CreateWebFunction gives it a Failed revision, and an endpoint update is stored+ * Successful. The create and update responses show the transitional state AWS reports. Invocation+ * through an endpoint domain is not part of this service.*/@ApplicationScopedpublic class LambdaWebService implements Resettable {@@ -594,10 +595,36 @@ public class LambdaWebService implements Resettable {String accountId = AwsArnUtils.parse(fn.functionArn).accountId();WebFunctionRevision.BuildConfig build = revision.buildConfig;long size;- try (S3Service.ObjectRead object = s3Service.openObject(build.bucket, build.key, build.versionId)) {+ try (S3Service.ObjectRead object = openCode(build)) {+ // AWS accepts an object of exactly this size, despite the wording.+ if (LambdaWebCode.MAX_BYTES < object.object().getSize()) {+ throw new AwsException("ValidationException", "Zipped size must be smaller than "+ + LambdaWebCode.MAX_BYTES + " bytes", 400);+ }size = code.store(accountId, region, fn.functionName, revision.revisionId, object.body());} catch (IOException e) {throw new UncheckedIOException("Could not close the code object s3://" + build.bucket + "/" + build.key, e);+ }+ if (size == 0) {+ // An empty object is an internal error on AWS.+ code.deleteRevision(accountId, region, fn.functionName, revision.revisionId);+ throw new LambdaWebInternalServerException();+ }+ OptionalLong unzipped = code.unzippedSize(accountId, region, fn.functionName, revision.revisionId);+ if (unzipped.isEmpty()) {+ revision.failureReason = NOT_A_ZIP;+ } else if (Long.compareUnsigned(LambdaWebCode.MAX_BYTES, unzipped.getAsLong()) < 0) {+ revision.failureReason = "Uncompressed code size " + Long.toUnsignedString(unzipped.getAsLong())+ + " bytes exceeds the maximum allowed size of " + LambdaWebCode.MAX_BYTES + " bytes";+ }+ if (revision.failureReason != null) {+ code.deleteRevision(accountId, region, fn.functionName, revision.revisionId);+ }+ }++ private S3Service.ObjectRead openCode(WebFunctionRevision.BuildConfig build) {+ try {+ return s3Service.openObject(build.bucket, build.key, build.versionId);} catch (AwsException e) {LOG.debugv("Web function code object s3://{0}/{1} is not readable: {2}", build.bucket, build.key,e.getMessage());@@ -614,15 +641,6 @@ public class LambdaWebService implements Resettable {throw new AwsException("ValidationException", "The S3 object " + object + " (versionId=" + build.versionId+ ") is inaccessible. Verify the request parameters and permissions are correct.", 400);}- if (size == 0) {- // An empty object is an internal error on AWS.- code.deleteRevision(accountId, region, fn.functionName, revision.revisionId);- throw new LambdaWebInternalServerException();- }- if (!code.opensAsZip(accountId, region, fn.functionName, revision.revisionId)) {- code.deleteRevision(accountId, region, fn.functionName, revision.revisionId);- revision.failureReason = NOT_A_ZIP;- }}private static void validateRevisionShape(LambdaWebValidation v, JsonNode request, String prefix) {diff --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 7339cd6a4a..0bd3d5736f 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@@ -467,6 +467,22 @@ class ZipExtractorTest {}}+ @Test+ void aPackageMayExpandToTheLimitItIsGiven(@TempDir Path codeStore) throws IOException {+ long limit = 512L * 1024 * 1024;+ Path archive = codeStore.resolve("code.zip");+ Path target = codeStore.resolve("fn");+ Files.write(archive, zipWithDeclaredSizes(300L * 1024 * 1024, 212L * 1024 * 1024));++ extractor.extractTo(archive, target, ZipExtractor.DEFAULT_MAX_ENTRIES, limit);+ assertTrue(Files.exists(target.resolve("entry0")));++ Files.write(archive, zipWithDeclaredSizes(300L * 1024 * 1024, 212L * 1024 * 1024 + 1));+ IOException thrown = assertThrows(IOException.class,+ () -> extractor.extractTo(archive, target, ZipExtractor.DEFAULT_MAX_ENTRIES, limit));+ assertEquals("ZIP archive exceeds the 536870912 byte expanded limit", thrown.getMessage());+ }+@Testvoid rejectsAnEntryWhoseCompressionMethodCannotBeRead(@TempDir Path target) throws IOException {// A package must never be half-deployed because an entry used a codec the reader doesdiff --git a/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebIntegrationTest.javaindex eb52fef28d..b28c3ba6ee 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebIntegrationTest.java@@ -663,4 +663,39 @@ class LambdaWebIntegrationTest {given().when().delete(BASE + "/web-functions/" + fn).then().statusCode(204);}++ @Test+ @Order(12)+ void codeThatUnzipsPastTheLimitFailsItsRevision() {+ String fn = FN + "-large";+ s3Service.putObject(BUCKET, "large.zip", LambdaWebZips.declaring(LambdaWebCode.MAX_BYTES + 1),+ "application/zip", Map.of());+ given().contentType("application/json")+ .body("""+ {"functionName": "%s",+ "revisionConfig": {"buildConfig": %s, "serviceConfig": {"executionRoleArn": "%s"}},+ "endpointConfig": {"endpointName": "dev", "endpointType": "HomeRegion",+ "authType": "ApplicationManaged", "autoDeploymentMode": "LatestRevision"}}+ """.formatted(fn, BUILD, ROLE))+ .when().put(BASE + "/web-functions")+ .then().statusCode(202);++ String large = given().contentType("application/json")+ .body("""+ {"buildConfig": {"codeConfig": {"s3Object": {"bucket": "%s", "key": "large.zip"}},+ "runtimeConfig": {"runtime": "nodejs24.x"}},+ "serviceConfig": {"executionRoleArn": "%s"}}+ """.formatted(BUCKET, ROLE))+ .when().post(BASE + "/web-functions/" + fn + "/revisions")+ .then().statusCode(202)+ .body("state", equalTo("Pending"))+ .extract().path("revisionId");+ given().when().get(BASE + "/web-functions/" + fn + "/revisions/" + large)+ .then().statusCode(200)+ .body("state", equalTo("Failed"))+ .body("stateReason", equalTo("Uncompressed code size 536870913 bytes exceeds the maximum allowed size"+ + " of 536870912 bytes"));++ given().when().delete(BASE + "/web-functions/" + fn).then().statusCode(204);+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebServiceTest.javaindex 66332321e3..14a2d99988 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebServiceTest.java@@ -658,7 +658,7 @@ class LambdaWebServiceTest {Path copy = code.file(ACCOUNT_ID, REGION, "app", "rev-aaaaa");Files.createDirectories(copy);- assertThrows(UncheckedIOException.class, () -> code.opensAsZip(ACCOUNT_ID, REGION, "app", "rev-aaaaa"));+ assertThrows(UncheckedIOException.class, () -> code.unzippedSize(ACCOUNT_ID, REGION, "app", "rev-aaaaa"));assertFalse(Files.exists(copy));}@@ -782,6 +782,69 @@ class LambdaWebServiceTest {}}+ @Test+ void aRevisionWhoseFilesAddUpPastTheLimitIsFailed() {+ S3Service s3 = mock(S3Service.class);+ LambdaWebService service = service(new MemoryStorageFactory(), "http://localhost:4566", s3);+ when(s3.openObject("code", "app.zip", null))+ .thenReturn(object(LambdaWebZips.declaring(LambdaWebCode.MAX_BYTES)));+ WebFunctionRevision full = service.createFunction(REGION, createRequest("app")).revisions.values()+ .iterator().next();+ when(s3.openObject("code", "app.zip", null))+ .thenReturn(object(LambdaWebZips.declaring(LambdaWebCode.MAX_BYTES + 1)));+ WebFunctionRevision over = service.createRevision(REGION, "app", revisionConfig(30));++ assertNull(full.failureReason);+ assertEquals("Uncompressed code size 536870913 bytes exceeds the maximum allowed size of 536870912 bytes",+ over.failureReason);+ LambdaWebCode code = new LambdaWebCode(storageDir.resolve("code"));+ assertTrue(Files.exists(code.file(ACCOUNT_ID, REGION, "app", full.revisionId)));+ assertFalse(Files.exists(code.file(ACCOUNT_ID, REGION, "app", over.revisionId)));+ }++ @Test+ void declaredSizesAddUpWithoutWrappingAround() {+ S3Service s3 = mock(S3Service.class);+ LambdaWebService service = service(new MemoryStorageFactory(), "http://localhost:4566", s3);+ when(s3.openObject("code", "app.zip", null))+ .thenReturn(object(LambdaWebZips.declaring(Long.MAX_VALUE, 1)));+ WebFunctionRevision signed = service.createFunction(REGION, createRequest("app")).revisions.values()+ .iterator().next();+ when(s3.openObject("code", "app.zip", null))+ .thenReturn(object(LambdaWebZips.declaring(Long.MAX_VALUE, Long.MAX_VALUE, 2)));+ WebFunctionRevision unsigned = service.createRevision(REGION, "app", revisionConfig(30));++ assertEquals("Uncompressed code size 9223372036854775808 bytes exceeds the maximum allowed size of "+ + "536870912 bytes", signed.failureReason);+ assertEquals("Uncompressed code size 18446744073709551615 bytes exceeds the maximum allowed size of "+ + "536870912 bytes", unsigned.failureReason);+ }++ @Test+ void anObjectPastTheZippedLimitIsRefusedAndCreatesNothing() throws IOException {+ S3Service s3 = mock(S3Service.class);+ LambdaWebService service = service(new MemoryStorageFactory(), "http://localhost:4566", s3);+ byte[] zip = LambdaWebZips.indexJs("");+ String refusal = "Zipped size must be smaller than 536870912 bytes";+ when(s3.openObject("code", "app.zip", null)).thenReturn(object(zip, LambdaWebCode.MAX_BYTES + 1));++ AwsException create = error(() -> service.createFunction(REGION, createRequest("app")));+ assertEquals("ValidationException", create.getErrorCode());+ assertEquals(400, create.getHttpStatus());+ assertEquals(refusal, create.getMessage());+ assertEquals("The function arn:aws:lambda:us-east-1:000000000000:web-function/app does not exist.",+ message(() -> service.getFunction(REGION, "app")));++ when(s3.openObject("code", "app.zip", null)).thenReturn(object(zip, LambdaWebCode.MAX_BYTES));+ service.createFunction(REGION, createRequest("app"));+ when(s3.openObject("code", "app.zip", null)).thenReturn(object(zip, LambdaWebCode.MAX_BYTES + 1));+ assertEquals(refusal, message(() -> service.createRevision(REGION, "app", revisionConfig(30))));+ assertEquals(1, service.getFunction(REGION, "app").revisions.size());+ try (Stream<Path> copies = Files.walk(storageDir.resolve("code"))) {+ assertEquals(1, copies.filter(Files::isRegularFile).count());+ }+ }+private ObjectNode stateFilter(String state) {ObjectNode request = mapper.createObjectNode();request.putArray("filters").addObject().put("name", "state").putArray("values").add(state);@@ -793,6 +856,12 @@ class LambdaWebServiceTest {new ByteArrayInputStream(bytes));}+ /** An object S3 reports as {@code size} bytes, whatever its body. */+ private static S3Service.ObjectRead object(byte[] bytes, long size) {+ return new S3Service.ObjectRead(new S3Object("code", "app.zip", size, "application/zip", "etag"),+ new ByteArrayInputStream(bytes));+ }+private static final class MemoryStorageFactory extends StorageFactory {private final Map<String, StorageBackend<String, ?>> stores = new HashMap<>();diff --git a/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebZips.java b/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebZips.javaindex 9b6b91a31b..75901934ce 100644--- a/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebZips.java+++ b/src/test/java/io/github/hectorvent/floci/services/lambdaweb/LambdaWebZips.java@@ -3,7 +3,10 @@ package io.github.hectorvent.floci.services.lambdaweb;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.UncheckedIOException;+import java.nio.ByteBuffer;+import java.nio.ByteOrder;import java.nio.charset.StandardCharsets;+import java.util.Arrays;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;@@ -24,4 +27,29 @@ public final class LambdaWebZips {}return bytes.toByteArray();}++ /** Files whose ZIP64 fields declare these sizes over empty data. */+ public static byte[] declaring(long... sizes) {+ byte[] empty = {3, 0};+ ByteBuffer out = ByteBuffer.allocate(256 * sizes.length + 22).order(ByteOrder.LITTLE_ENDIAN);+ ByteBuffer central = ByteBuffer.allocate(128 * sizes.length).order(ByteOrder.LITTLE_ENDIAN);+ for (int i = 0; i < sizes.length; i++) {+ byte[] name = ("file" + i).getBytes(StandardCharsets.UTF_8);+ int offset = out.position();+ out.putInt(0x04034b50).putShort((short) 45).putShort((short) 0).putShort((short) 8)+ .putInt(0).putInt(0).putInt(-1).putInt(-1).putShort((short) name.length).putShort((short) 20)+ .put(name).putShort((short) 1).putShort((short) 16).putLong(sizes[i]).putLong(empty.length)+ .put(empty);+ central.putInt(0x02014b50).putShort((short) 45).putShort((short) 45).putShort((short) 0)+ .putShort((short) 8).putInt(0).putInt(0).putInt(-1).putInt(-1).putShort((short) name.length)+ .putShort((short) 20).putShort((short) 0).putShort((short) 0).putShort((short) 0).putInt(0)+ .putInt(offset).put(name).putShort((short) 1).putShort((short) 16).putLong(sizes[i])+ .putLong(empty.length);+ }+ int centralOffset = out.position();+ out.put(central.flip()).putInt(0x06054b50).putShort((short) 0).putShort((short) 0)+ .putShort((short) sizes.length).putShort((short) sizes.length).putInt(central.limit())+ .putInt(centralOffset).putShort((short) 0);+ return Arrays.copyOf(out.array(), out.position());+ }}