WarPathUtils.java

package org.appfuse;

import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.SelectorUtils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.jar.JarOutputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 * Static utility class to help with War file processing.
 */
public class WarPathUtils
{
  public static final Pattern WEBINF_CLASSES_PATTERN;

  static
  {
    WEBINF_CLASSES_PATTERN = Pattern.compile("^[/\\\\]?web-inf[/\\\\]classes[/\\\\]?(.*)$", Pattern.CASE_INSENSITIVE);
  }

  /**
   * Unpack the WEB-INF/classes directory from the specified war file if the contents of the target
   * directory is older than the war file.
   *
   * @param warFile        The war file to unpack.
   * @param classesJarFile The target jar file which will hold the contents of the WEB-INF/classes directory.
   * @param includes Comma separated list of resource patterns to include in the path
   * @param excludes Comma separated list of resource patterns to exclude from the path.
   * @throws IOException if an I/O error occurs.
   */
  public static void unpackWarClassesIfNewer(File warFile, File classesJarFile, String includes, String excludes) throws IOException
  {
    boolean process = false;
    if (!classesJarFile.exists() || warFile.lastModified() > classesJarFile.lastModified())
    {
      process = true;
    }

    if (process)
    {
      ZipFile zipFile = new ZipFile(warFile);
      JarOutputStream classesJarOutputStream = new JarOutputStream(new FileOutputStream(classesJarFile));
      try
      {
        unpackWebInfClasses(zipFile, classesJarOutputStream, includes, excludes);
      }
      finally
      {
        closeZipFile(zipFile);
        closeOutputStream(classesJarOutputStream);
      }
    }
  }

  private static void closeOutputStream(JarOutputStream classesJarOutputStream)
  {
    if (classesJarOutputStream != null)
    {
      try
      {
        classesJarOutputStream.close();
      }
      catch (IOException e)
      {
        // do nothing.
      }
    }
  }

  private static void closeZipFile(ZipFile zipFile)
  {
    if (zipFile != null)
    {
      try
      {
        zipFile.close();
      }
      catch (IOException e)
      {
        // do nothing.
      }
    }
  }

  /**
   * Extract the WEB-INF/classes entries from the specified war file into the named directory.
   *
   * @param zipFile                The war file to unpack
   * @param classesJarOutputStream The target directory.
   * @param includes               Comma separated patterns to match against resources to include
   * @param excludes               Comma separated patterns to match against resources to exclude
   * @throws IOException if an I/O error occurs during the unpacking.
   */
  public static void unpackWebInfClasses(ZipFile zipFile, JarOutputStream classesJarOutputStream, String includes, String excludes) throws IOException
  {
    Enumeration zipEntries = zipFile.entries();

    String[] includePatterns;

    if (StringUtils.isNotEmpty(includes))
    {
      includePatterns = StringUtils.split(includes, ",");
    }
    else
    {
      includePatterns = new String[]{"**"};
    }

    String[] excludesPattern;

    if (StringUtils.isNotEmpty(excludes))
    {
      excludesPattern = StringUtils.split(excludes, ",");
    }
    else
    {
      excludesPattern = new String[0];
    }

    while (zipEntries.hasMoreElements())
    {
      ZipEntry zipEntry = (ZipEntry) zipEntries.nextElement();
      Matcher matcher = WEBINF_CLASSES_PATTERN.matcher(zipEntry.getName());
      if (matcher.matches() && matcher.group(1).length() > 0)
      {
        String classesEntry = matcher.group(1);

        if (matches(classesEntry, includePatterns))
        {
          if (!matches(classesEntry, excludesPattern))
          {
            ZipEntry jarEntry = new ZipEntry(classesEntry);

            jarEntry.setComment(zipEntry.getComment());
            jarEntry.setExtra(zipEntry.getExtra());
            jarEntry.setMethod(zipEntry.getMethod());
            jarEntry.setTime(zipEntry.getTime());
            jarEntry.setSize(zipEntry.getSize());
            jarEntry.setCompressedSize(zipEntry.getCompressedSize());
            jarEntry.setCrc(zipEntry.getCrc());
            classesJarOutputStream.putNextEntry(jarEntry);
            byte[] readBuffer = new byte[1024];
            int readLength;
            InputStream inputStream = zipFile.getInputStream(zipEntry);
            while ((readLength = inputStream.read(readBuffer)) >= 0)
            {
              classesJarOutputStream.write(readBuffer, 0, readLength);
            }
          }
        }
      }
    }
  }

  private static boolean matches(String entry, String[] patterns)
  {
    entry = replaceFileSeparator(entry);
    for (int i = 0; i < patterns.length; i++)
    {
      String pattern = replaceFileSeparator(patterns[i].trim());
      if (SelectorUtils.matchPath(pattern, entry))
      {
        return true;
      }

    }
    return false;
  }

  private static String replaceFileSeparator(String path)
  {
    path = path.replace('/', File.separatorChar);
    path = path.replace('\\', File.separatorChar);
    return path;
  }

}