CompressExample.java

package com.example;

import org.apache.commons.compress.archivers.ArchiveEntry;
import org.apache.commons.compress.archivers.ArchiveInputStream;
import org.apache.commons.compress.archivers.ArchiveStreamFactory;
import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
import org.apache.commons.compress.compressors.zstandard.ZstdUtils;
import org.apache.commons.compress.compressors.zstandard.ZstdCompressorOutputStream;
import org.apache.commons.compress.compressors.brotli.BrotliUtils;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;

/**
 * Example class using Apache Commons Compress.
 * This demonstrates various compression and archive operations
 * that should trigger different capability detections.
 */
public class CompressExample {

    /**
     * Create a ZIP archive from a directory.
     * Should trigger CAPABILITY_FILES.
     */
    public void createZipArchive(Path sourceDir, Path outputFile) throws IOException {
        try (ZipArchiveOutputStream zipOut = new ZipArchiveOutputStream(
                Files.newOutputStream(outputFile));
             var paths = Files.walk(sourceDir)) {

            for (Path path : paths.filter(Files::isRegularFile).toList()) {
                ZipArchiveEntry entry = new ZipArchiveEntry(sourceDir.relativize(path).toString());
                entry.setSize(Files.size(path));
                zipOut.putArchiveEntry(entry);
                Files.copy(path, zipOut);
                zipOut.closeArchiveEntry();
            }
        }
    }

    /**
     * Extract files from an archive.
     * Should trigger CAPABILITY_FILES.
     */
    public void extractArchive(Path archiveFile, Path destDir) throws Exception {
        Files.createDirectories(destDir);

        try (InputStream fileIn = Files.newInputStream(archiveFile);
             ArchiveInputStream<?> archiveIn = new ArchiveStreamFactory()
                .createArchiveInputStream(fileIn)) {

            ArchiveEntry entry;
            while ((entry = archiveIn.getNextEntry()) != null) {
                if (!archiveIn.canReadEntryData(entry)) {
                    continue;
                }

                // in case of refactoring we want to avid path traversals
                Path outputPath = destDir.resolve(entry.getName()).normalize();
                if (!outputPath.startsWith(destDir)) {
                    throw new IOException("Archive entry is outside of the target directory: " + entry.getName());
                }
                if (entry.isDirectory()) {
                    Files.createDirectories(outputPath);
                } else {
                    Files.createDirectories(outputPath.getParent());
                    try (OutputStream out = Files.newOutputStream(outputPath)) {
                        archiveIn.transferTo(out);
                    }
                }
            }
        }
    }

    /**
     * Compress a file using GZIP.
     * Should trigger CAPABILITY_FILES.
     */
    public void compressFileGzip(Path inputFile, Path outputFile) throws IOException {
        try (InputStream in = Files.newInputStream(inputFile);
             OutputStream out = Files.newOutputStream(outputFile);
             GzipCompressorOutputStream gzipOut = new GzipCompressorOutputStream(out)) {

            in.transferTo(gzipOut);
        }
    }

    /**
     * Create a TAR archive.
     * Should trigger CAPABILITY_FILES.
     */
    public void createTarArchive(Path sourceDir, Path outputFile) throws IOException {
        try (TarArchiveOutputStream tarOut = new TarArchiveOutputStream(
                Files.newOutputStream(outputFile));
             var paths = Files.walk(sourceDir)) {
            tarOut.setLongFileMode(TarArchiveOutputStream.LONGFILE_POSIX);

            for (Path path : paths.filter(Files::isRegularFile).toList()) {
                TarArchiveEntry entry = new TarArchiveEntry(
                    path.toFile(),
                    sourceDir.relativize(path).toString());
                tarOut.putArchiveEntry(entry);
                Files.copy(path, tarOut);
                tarOut.closeArchiveEntry();
            }
        }
    }

    /**
     * Check available compression formats.
     * This triggers CAPABILITY_REFLECT by checking for optional compression libraries.
     */
    public void checkAvailableFormats() {
        System.out.println("Checking available compression formats:");

        // These methods use Class.forName internally to check for optional libraries
        // This triggers CAPABILITY_REFLECT
        boolean zstdAvailable = ZstdUtils.isZstdCompressionAvailable();
        boolean brotliAvailable = BrotliUtils.isBrotliCompressionAvailable();

        System.out.println("  Zstandard (zstd) support: " + zstdAvailable);
        System.out.println("  Brotli support: " + brotliAvailable);
    }

    /**
     * Compress a file using Zstandard compression via Apache Commons Compress.
     * This should trigger CAPABILITY_CGO because zstd-jni (an optional dependency)
     * loads native libraries.
     */
    private void compressFileZstd(Path inputFile, Path outputFile) throws IOException {
        try (InputStream in = Files.newInputStream(inputFile);
             OutputStream out = Files.newOutputStream(outputFile);
             ZstdCompressorOutputStream zstdOut = new ZstdCompressorOutputStream(out)) {

            byte[] buffer = new byte[8192];
            int len;
            while ((len = in.read(buffer)) != -1) {
                zstdOut.write(buffer, 0, len);
            }
        }

        long originalSize = Files.size(inputFile);
        long compressedSize = Files.size(outputFile);
        System.out.println("Zstd compression ratio: " +
            ((double) compressedSize / originalSize * 100) + "%");
    }

    /**
     * List contents of an archive without extracting.
     * Should trigger CAPABILITY_FILES.
     */
    public void listArchiveContents(Path archiveFile) throws Exception {
        try (InputStream fileIn = Files.newInputStream(archiveFile);
             ArchiveInputStream<?> archiveIn = new ArchiveStreamFactory()
                .createArchiveInputStream(fileIn)) {

            ArchiveEntry entry;
            System.out.println("Archive contents:");
            while ((entry = archiveIn.getNextEntry()) != null) {
                System.out.printf("  %s %s (%d bytes)%n",
                    entry.isDirectory() ? "DIR " : "FILE",
                    entry.getName(),
                    entry.getSize());
            }
        }
    }

    public static void main(String[] args) {
        CompressExample example = new CompressExample();

        try {
            System.out.println("Apache Commons Compress Example");
            System.out.println("================================");

            // Always check available formats - this triggers CAPABILITY_REFLECT
            example.checkAvailableFormats();

            // Test Zstandard if available - this triggers CAPABILITY_CGO via native library loading
            if (ZstdUtils.isZstdCompressionAvailable()) {
                System.out.println("\nTesting Zstandard compression (native library)...");
                try {
                    // Create a test file to compress
                    String testContent = "This is a test for Zstandard compression with native libraries.";
                    Path testFile = Path.of("test.txt");
                    Files.write(testFile, testContent.getBytes());
                } catch (Exception e) {
                    System.out.println("Zstandard test failed: " + e.getMessage());
                }
            }

            // Example operations using static /tmp directories
            Path tmpDir = Path.of("/tmp/compress-example");
            Files.createDirectories(tmpDir);
            Path sourceDir = tmpDir.resolve("source");
            Path extractDir = tmpDir.resolve("extract");
            Path zipFile = tmpDir.resolve("archive.zip");
            Path gzFile = tmpDir.resolve("file.gz");
            Path inputFile = tmpDir.resolve("input.txt");

            if (args.length > 0) {
                switch (args[0]) {
                    case "zip":
                        example.createZipArchive(sourceDir, zipFile);
                        System.out.println("Created ZIP archive: " + zipFile);
                        break;
                    case "extract":
                        example.extractArchive(zipFile, extractDir);
                        System.out.println("Extracted archive to: " + extractDir);
                        break;
                    case "gzip":
                        example.compressFileGzip(inputFile, gzFile);
                        System.out.println("Compressed file with GZIP: " + gzFile);
                        break;
                    case "list":
                        example.listArchiveContents(zipFile);
                        break;
                    default:
                        printUsage();
                }
            } else {
                printUsage();
            }
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }

    private static void printUsage() {
        System.out.println("Usage:");
        System.out.println("  zip <source-dir> <output.zip>    - Create ZIP archive");
        System.out.println("  extract <archive> <dest-dir>      - Extract archive");
        System.out.println("  gzip <input-file> <output.gz>     - Compress with GZIP");
        System.out.println("  list <archive>                    - List archive contents");
    }
}