commons-compress

Creating a tar.gz with commons-compress

By jcscoobyrs on Mon, 08/16/2010 - 14:36

Recently I needed to take a Linux-only Java application and make it work on Windows. One of the things I had to do was remove a lot of calls to command line utilities. One of those was where we used tar to create a tar.gz of a directory structure. Googling around for creating a tar.gz in Java quickly pointed me to the commons-compress project. The problem was that there was very little documentation and no full examples to go off of. I ended up getting this code working and below is an example. In this example you will see two Java methods that are heavily documented and use together will allow you to create a .tar.gz of a directory. Of course, this example could be made better and is simple for brevity. Enjoy.

  1. /**
  2.  * Creates a tar.gz file at the specified path with the contents of the specified directory.
  3.  * 
  4.  * @param dirPath The path to the directory to create an archive of
  5.  * @param archivePath The path to the archive to create
  6.  * 
  7.  * @throws IOException If anything goes wrong
  8.  */
  9. public static void createTarGzOfDirectory(String directoryPath, String tarGzPath) throws IOException {
  10.     FileOutputStream fOut = null;
  11.     BufferedOutputStream bOut = null;
  12.     GzipCompressorOutputStream gzOut = null;
  13.     TarArchiveOutputStream tOut = null;
  14.  
  15.     try {
  16.         fOut = new FileOutputStream(new File(tarGzPath));
  17.         bOut = new BufferedOutputStream(fOut);
  18.         gzOut = new GzipCompressorOutputStream(bOut);
  19.         tOut = new TarArchiveOutputStream(gzOut);
  20.  
  21.         addFileToTarGz(tOut, directoryPath, "");
  22.     } finally {
  23.         tOut.finish();
  24.  
  25.         tOut.close();
  26.         gzOut.close();
  27.         bOut.close();
  28.         fOut.close();
  29.     }
  30. }
  31.  
  32. /**
  33.  * Creates a tar entry for the path specified with a name built from the base passed in and the file/directory
  34.  * name.  If the path is a directory, a recursive call is made such that the full directory is added to the tar.
  35.  * 
  36.  * @param tOut The tar file's output stream
  37.  * @param path The filesystem path of the file/directory being added
  38.  * @param base The base prefix to for the name of the tar file entry
  39.  * 
  40.  * @throws IOException If anything goes wrong
  41.  */
  42. private static void addFileToTarGz(TarArchiveOutputStream tOut, String path, String base) throws IOException {
  43.     File f = new File(path);
  44.     String entryName = base + f.getName();
  45.     TarArchiveEntry tarEntry = new TarArchiveEntry(f, entryName);
  46.  
  47.     tOut.setLongFileMode(TarArchiveOutputStream.LONGFILE_GNU);
  48.     tOut.putArchiveEntry(tarEntry);
  49.  
  50.     if (f.isFile()) {
  51.         IOUtils.copy(new FileInputStream(f), tOut);
  52.  
  53.         tOut.closeArchiveEntry();
  54.     } else {
  55.         tOut.closeArchiveEntry();
  56.  
  57.         File[] children = f.listFiles();
  58.  
  59.         if (children != null) {
  60.             for (File child : children) {
  61.                 addFileToTarGz(tOut, child.getAbsolutePath(), entryName + "/");
  62.             }
  63.         }
  64.     }
  65. }

The example could easily be tested by creating a static main method that looks like this:

  1. ...
  2. /**                                                                                                                                                                                                   
  3.  * Application entry point.                                                                                                                                                                           
  4.  *                                                                                                                                                                                                    
  5.  * @param args The command line arguments.                                                                                                                                                            
  6.  */
  7. public static void main( String[] args )
  8. {
  9.     createTarGzOfDirectory("/Users/jwhitlock/some_directory", "/tmp/some_directory.tar.gz");
  10. }
  11. ...

And there you have it...a complete example of how to use commons-compress to create a .tar.gz of a directory.

Share this post:
Java: 
commons-compress