refactor(api): use NightCompress library for reading CBX

.github/workflows/test-suite.yml

@@ -56,6 +56,15 @@ jobs:
           restore-keys: |
             gradle-${{ runner.os }}-
 
+      # Needed for NightCompress
+      - name: Install libarchive
+        run: |
+          sudo apt-get install libarchive-dev --yes
+
+          # Place libarchive somewhere that java looks for it.
+          sudo mkdir -p /usr/java/packages/lib/
+          sudo cp /usr/lib/x86_64-linux-gnu/libarchive.* /usr/java/packages/lib/
+
       - name: Execute Backend Tests
         id: backend_tests
         run: |

Dockerfile

@@ -35,8 +35,6 @@ RUN set -eux; \
     jar_path="$(find build/libs -maxdepth 1 -name '*.jar' ! -name '*plain.jar' | head -n 1)"; \
     cp "$jar_path" /workspace/booklore-api/app.jar
 
-FROM linuxserver/unrar:7.1.10 AS unrar-layer
-
 FROM mwader/static-ffmpeg:8.1 AS ffprobe-layer
 
 FROM scratch AS kepubify-layer-amd64
@@ -70,13 +68,15 @@ ENV JAVA_TOOL_OPTIONS="-XX:+UseShenandoahGC \
     -XX:InitialRAMPercentage=8.0 \
     -XX:+ExitOnOutOfMemoryError"
 
-RUN apk add --no-cache su-exec libstdc++ libgcc && \
+RUN apk add --no-cache su-exec libstdc++ libgcc libarchive && \
     mkdir -p /bookdrop
 
+# Manually link `libarchive.so.13` so java and other libraries can see it
+RUN ln -s /usr/lib/libarchive.so.13 /usr/lib/libarchive.so
+
 COPY packaging/docker/entrypoint.sh /usr/local/bin/entrypoint.sh
 RUN chmod +x /usr/local/bin/entrypoint.sh
 
-COPY --from=unrar-layer /usr/bin/unrar-alpine /usr/local/bin/unrar
 COPY --from=ffprobe-layer /ffprobe /usr/local/bin/ffprobe
 COPY --from=kepubify-layer /kepubify /usr/local/bin/kepubify
 
@@ -102,4 +102,4 @@ ARG BOOKLORE_PORT=6060
 EXPOSE ${BOOKLORE_PORT}
 
 ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
-CMD ["java", "-jar", "/app/app.jar"]
+CMD ["java", "--enable-native-access=ALL-UNNAMED", "-jar", "/app/app.jar"]

booklore-api/build.gradle.kts

@@ -86,8 +86,8 @@ dependencies {
     // --- Audio Metadata (Audiobook Support) ---
     implementation("com.github.RouHim:jaudiotagger:2.0.19")
 
-    // --- UNRAR Support ---
-    implementation("com.github.junrar:junrar:7.5.8")
+    // --- Archive Support ---
+    implementation("com.github.gotson.nightcompress:nightcompress:1.1.1")
 
     // --- JSON & Web Scraping ---
     implementation("org.jsoup:jsoup:1.22.1")
@@ -139,7 +139,7 @@ hibernate {
 
 tasks.named<Test>("test") {
     useJUnitPlatform()
-    jvmArgs("-XX:+EnableDynamicAgentLoading")
+    jvmArgs("-XX:+EnableDynamicAgentLoading", "--enable-native-access=ALL-UNNAMED")
     finalizedBy(tasks.named("jacocoTestReport"))
 }
 

booklore-api/src/main/java/org/booklore/service/ArchiveService.java

@@ -0,0 +1,124 @@
+package org.booklore.service;
+
+import com.github.gotson.nightcompress.Archive;
+import com.github.gotson.nightcompress.ArchiveEntry;
+import com.github.gotson.nightcompress.LibArchiveException;
+import jakarta.annotation.PostConstruct;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Stream;
+
+@Slf4j
+@Service
+public class ArchiveService {
+    @PostConstruct
+    public void checkArchiveAvailable() {
+        try {
+            // We want to check the version early because it allows for
+            // NightCompress to preload the libarchive library in a safe
+            // thread.  Loading native libraries is not a thread safe operation.
+            if (!Archive.isAvailable()) {
+                log.warn("LibArchive is not available");
+            }
+        } catch (Throwable e) {
+            log.error("LibArchive could not be loaded", e);
+        }
+    }
+
+    public static boolean isAvailable() {
+        return Archive.isAvailable();
+    }
+
+    public static class Entry {
+        private Entry() {}
+
+        @Getter
+        private String name;
+
+        @Getter
+        private long size;
+    }
+
+    private Entry getEntryFromArchiveEntry(ArchiveEntry archiveEntry) {
+        Entry entry = new Entry();
+
+        entry.name = archiveEntry.getName();
+        entry.size = archiveEntry.getSize();
+
+        return entry;
+    }
+
+    public List<Entry> getEntries(Path path) throws IOException {
+        return streamEntries(path).toList();
+    }
+
+    public Stream<Entry> streamEntries(Path path) throws IOException {
+        try {
+            return Archive.getEntries(path)
+                    .stream()
+                    .map(this::getEntryFromArchiveEntry);
+        } catch (LibArchiveException e) {
+            throw new IOException("Failed to read archive", e);
+        }
+    }
+
+    public List<String> getEntryNames(Path path) throws IOException {
+        return streamEntryNames(path).toList();
+    }
+
+    public Stream<String> streamEntryNames(Path path) throws IOException {
+        try {
+            return Archive.getEntries(path)
+                    .stream()
+                    .map(ArchiveEntry::getName);
+        } catch (LibArchiveException e) {
+            throw new IOException("Failed to read archive", e);
+        }
+    }
+
+    public long transferEntryTo(Path path, String entryName, OutputStream outputStream) throws IOException {
+        // We cannot directly use the NightCompress `InputStream` as it is limited
+        // in its implementation and will cause fatal errors.  Instead, we can use
+        // the `transferTo` on an output stream to copy data around.
+        try (InputStream inputStream = Archive.getInputStream(path, entryName)) {
+            if (inputStream != null) {
+                return inputStream.transferTo(outputStream);
+            }
+        } catch (Exception e) {
+            throw new IOException("Failed to extract from archive: " + e.getMessage(), e);
+        }
+
+        throw new IOException("Entry not found in archive");
+    }
+
+    public byte[] getEntryBytes(Path path, String entryName) throws IOException {
+        try (
+                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        ) {
+            transferEntryTo(path, entryName, outputStream);
+
+            return outputStream.toByteArray();
+        }
+    }
+
+    public long extractEntryToPath(Path path, String entryName, Path outputPath) throws IOException {
+        try (InputStream inputStream = Archive.getInputStream(path, entryName)) {
+            if (inputStream != null) {
+                return Files.copy(inputStream, outputPath);
+            }
+        } catch (Exception e) {
+            throw new IOException("Failed to extract from archive: " + e.getMessage(), e);
+        }
+
+        throw new IOException("Entry not found in archive");
+    }
+}