close native resources

Author: gregsh

README.md

@@ -16,7 +16,7 @@ We reuse standard `java.util.zip.ZipOutputStream` and
 1. Collect all zip entries and their bytes for each input file in parallel.
    For each input file:
    - Get a `ByteArrayOutputStream` and a `ZipOutputStream` on top of it
-   - Write an entry to a zip stream. Do not close it to avoid writing an unneeded central directory
+   - Write an entry to the zip stream skipping the central directory using `SingleEntryZipOutputStream`.
    - Get the bytes from the byte stream
 
 ```java
@@ -25,33 +25,35 @@ We reuse standard `java.util.zip.ZipOutputStream` and
       // for each input file in parallel:
       var out = new ByteArrayOutputStream();
       var zipEntry = new ZipEntry(filePathRelativeToZipRoot);
-      var zip = new ZipOutputStream(out);
-      try (var fileStream = Files.newInputStream(filePath)) {
-        zip.putNextEntry(zipEntry);
-        fileStream.transferTo(zip);
-        zip.closeEntry();
+      try (var zip = new SingleEntryZipOutputStream(out)) {
+        try (var fileStream = Files.newInputStream(filePath)) {
+          zip.putNextEntry(zipEntry);
+          fileStream.transferTo(zip);
+          zip.closeEntry();
+        }
       }
       zipEntries.put(zipEntry, out.toByteArray());
 ```
 
 2. Write all entries and bytes sequentially to a target zip file:
    - Get a `FileOutputStream` and a `ZipOutputStream` on top of it
-   - Write bytes of all entries to a file stream updating zip stream state
-   - Write the central directory by closing the zip stream
+   - Write bytes of all entries to the file stream updating the zip stream state
+   - Write the central directory by closing the zip stream as usual
 
 ```java
     try (var os = Files.newOutputStream(zipFile)) {
-      var zip = new ZipOutputStream(os);
-      var offset = 0L;
-      for (Map.Entry<ZipEntry, byte[]> o : zipEntries.entrySet()) {
-        var zipEntry = o.getKey();
-        var bytes = o.getValue();
-        zip.xEntries.add(new XEntry(zipEntry, offset)); // via reflection
-        os.write(bytes);
-        offset += bytes.length;
+      try (var zip = new ZipOutputStream(os)) {
+         var offset = 0L;
+         for (Map.Entry<ZipEntry, byte[]> o : zipEntries.entrySet()) {
+           var zipEntry = o.getKey();
+           var bytes = o.getValue();
+           zip.xEntries.add(new XEntry(zipEntry, offset)); // via reflection
+           os.write(bytes);
+           offset += bytes.length;
+         }
+         zip.offset = offset; // via reflection
+         // write the central directory on close
       }
-      zip.offset = offset; // via reflection
-      zip.close();
     }
 ```
 

src/main/java/parallelZip/MainJava.java

@@ -64,11 +64,12 @@ private static void addZipEntryToMap(Path relativePath, Path path, ConcurrentHas
     var out = new ByteArrayOutputStream();
     var zipEntry = new ZipEntry(relativePath.toString());
     // skip the central directory writing by _not_ closing the zip stream
-    var zip = new ZipOutputStream(out);
-    try (var fileStream = new BufferedInputStream(Files.newInputStream(path))) {
-      zip.putNextEntry(zipEntry);
-      fileStream.transferTo(zip);
-      zip.closeEntry();
+    try (var zip = new SingleEntryZipOutputStream(out)) {
+      try (var fileStream = new BufferedInputStream(Files.newInputStream(path))) {
+        zip.putNextEntry(zipEntry);
+        fileStream.transferTo(zip);
+        zip.closeEntry();
+      }
     }
     catch (IOException e) {
       throw new RuntimeException(e);
@@ -93,19 +94,19 @@ private static void addZipFileEntriesToMap(Path path, ConcurrentHashMap<ZipEntry
   private static void writeZipEntriesToZip(Path zipFile, List<Map.Entry<ZipEntry, byte[]>> list) throws Exception {
     // a zip is just its entries and a central directory at the end
     try (var os = new BufferedOutputStream(Files.newOutputStream(zipFile))) {
-      var zip = new ZipOutputStream(os);
-      var xEntries = (Vector<Object>)varEntries.get(zip);
-      var offset = 0L;
-      for (var item : list) {
-        var zipEntry = item.getKey();
-        var bytes = item.getValue();
-        xEntries.add(xEntryConstructor.newInstance(zipEntry, offset));
-        os.write(bytes);
-        offset += bytes.length;
+      try (var zip = new ZipOutputStream(os)) {
+        var xEntries = (Vector<Object>)varEntries.get(zip);
+        var offset = 0L;
+        for (var item : list) {
+          var zipEntry = item.getKey();
+          var bytes = item.getValue();
+          xEntries.add(xEntryConstructor.newInstance(zipEntry, offset));
+          os.write(bytes);
+          offset += bytes.length;
+        }
+        varWritten.set(zip, offset);
+        // write the central directory on close
       }
-      // write the central directory
-      varWritten.set(zip, offset);
-      zip.close();
     }
   }
 

src/main/kotlin/parallelZip/MainKotlin.kt

@@ -57,7 +57,7 @@ private fun addZipEntryToMap(relativePath: Path, path: Path, zipEntries: Concurr
     val out = ByteArrayOutputStream()
     val zipEntry = ZipEntry(relativePath.toString())
     // skip the central directory writing by _not_ closing the zip stream
-    ZipOutputStream(out).let {
+    SingleEntryZipOutputStream(out).use {
         it.putNextEntry(zipEntry)
         path.inputStream().buffered().use { s -> s.copyTo(it) }
         it.closeEntry()
@@ -77,17 +77,17 @@ private fun addZipFileEntriesToMap(path: Path, zipEntries: ConcurrentHashMap<Zip
 private fun writeZipEntriesToZip(zipFile: Path, list: List<Map.Entry<ZipEntry, ByteArray>>) {
     // a zip is just its entries and a central directory at the end
     zipFile.outputStream().buffered().use { os ->
-        val zip = ZipOutputStream(os)
-        val xEntries = varEntries.get(zip) as Vector<Any>
-        var offset = 0L
-        list.forEach { (zipEntry, bytes) ->
-            xEntries.add(xEntryConstructor.newInstance(zipEntry, offset))
-            os.write(bytes)
-            offset += bytes.size.toLong()
+        ZipOutputStream(os).use { zip ->
+            val xEntries = varEntries.get(zip) as Vector<Any>
+            var offset = 0L
+            list.forEach { (zipEntry, bytes) ->
+                xEntries.add(xEntryConstructor.newInstance(zipEntry, offset))
+                os.write(bytes)
+                offset += bytes.size.toLong()
+            }
+            varWritten.set(zip, offset)
+            // write the central directory on close
         }
-        // write the central directory
-        varWritten.set(zip, offset)
-        zip.close()
     }
 }
 

src/main/kotlin/parallelZip/SingleEntryZipOutputStream.kt

@@ -0,0 +1,10 @@
+package parallelZip
+
+import java.io.OutputStream
+import java.util.zip.ZipOutputStream
+
+class SingleEntryZipOutputStream(out: OutputStream) : ZipOutputStream(out) {
+    override fun finish() {
+        closeEntry()
+    }
+}