/******************************************************************************
* Copyright (c) 2006, 2010 VMware Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Apache License v2.0 which accompanies this distribution.
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html and the Apache License v2.0
* is available at http://www.opensource.org/licenses/apache2.0.php.
* You may elect to redistribute this code under either of these licenses.
*
* Contributors:
* VMware Inc.
*****************************************************************************/
package org.eclipse.gemini.blueprint.test.internal.util.jar;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.jar.Manifest;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.gemini.blueprint.test.internal.util.jar.storage.MemoryStorage;
import org.eclipse.gemini.blueprint.test.internal.util.jar.storage.Storage;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.util.StringUtils;
/**
* Helper class for creating Jar files. Note that this class is stateful and the
* same instance should not be reused.
*
* @author Costin Leau
*
*/
public class JarCreator {
private static final Log log = LogFactory.getLog(JarCreator.class);
public static final String EVERYTHING_PATTERN = "/**/*";
private static final String CLASS_EXT = ".class";
private String[] contentPattern = new String[] { EVERYTHING_PATTERN };
private ResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver();
private Storage storage = new MemoryStorage();
private String rootPath = determineRootPath();
private boolean addFolders = true;
/** collection of packages contained by this jar */
private Collection containedPackages = new TreeSet();
/**
* Resources' root path (the root path does not become part of the jar).
*
* @return the root path
*/
public String determineRootPath() {
return Thread.currentThread().getContextClassLoader().getResource(".").toString();
}
/**
* Actual jar creation.
*
* @param manifest to use
* @param entries array of resource to include in the jar
* @return the number of bytes written to the underlying stream.
*
* @throws IOException
*/
protected int addJarContent(Manifest manifest, Map entries) throws IOException {
// load manifest
// add it to the jar
if (log.isTraceEnabled()) {
if (manifest != null)
log.trace("Adding MANIFEST.MF [" + manifest.getMainAttributes().entrySet() + "]");
log.trace("Adding entries:");
Set key = entries.keySet();
for (Iterator iter = key.iterator(); iter.hasNext();) {
log.trace(iter.next());
}
}
return JarUtils.createJar(manifest, entries, storage.getOutputStream());
}
/**
* Create a jar using the current settings and return a {@link Resource}
* pointing to the jar.
*
* @param manifest
*/
public Resource createJar(Manifest manifest) {
return createJar(manifest, resolveContent());
}
/**
* Create a jar using the current settings and return a {@link Resource}
* pointing to the jar.
*
* @param manifest
*/
public Resource createJar(Manifest manifest, Map content) {
try {
addJarContent(manifest, content);
return storage.getResource();
}
catch (IOException ex) {
throw (RuntimeException) new IllegalStateException("Cannot create jar").initCause(ex);
}
}
/**
* Small utility method used for determining the file name by striping the
* root path from the file full path.
*
* @param rootPath
* @param resource
* @return
*/
private String determineRelativeName(String rootPath, Resource resource) {
try {
String path = StringUtils.cleanPath(resource.getURL().toExternalForm());
return path.substring(path.indexOf(rootPath) + rootPath.length());
}
catch (IOException ex) {
throw (RuntimeException) new IllegalArgumentException("illegal resource " + resource.toString()).initCause(ex);
}
}
/**
* Transform the pattern and rootpath into actual resources.
*
* @return
* @throws Exception
*/
private Resource[][] resolveResources() {
ResourcePatternResolver resolver = getPatternResolver();
String[] patterns = getContentPattern();
Resource[][] resources = new Resource[patterns.length][];
// transform Strings into Resources
for (int i = 0; i < patterns.length; i++) {
StringBuilder buffer = new StringBuilder(rootPath);
// do checking on lost slashes
if (!rootPath.endsWith(JarUtils.SLASH) && !patterns[i].startsWith(JarUtils.SLASH))
buffer.append(JarUtils.SLASH);
buffer.append(patterns[i]);
try {
resources[i] = resolver.getResources(buffer.toString());
}
catch (IOException ex) {
IllegalStateException re = new IllegalStateException("cannot resolve pattern " + buffer.toString());
re.initCause(ex);
throw re;
}
}
return resources;
}
/**
* Resolve the jar content based on its path. Will return a map containing
* the entries relative to the jar root path as keys and Spring Resource
* pointing to the actual resources as values. It will also determine the
* packages contained by this package.
*
* @return
*/
public Map resolveContent() {
Resource[][] resources = resolveResources();
URL rootURL;
String rootP = getRootPath();
try {
rootURL = new URL(rootP);
}
catch (MalformedURLException ex) {
throw (RuntimeException) new IllegalArgumentException("illegal root path given " + rootP).initCause(ex);
}
String rootPath = StringUtils.cleanPath(rootURL.getPath());
// remove duplicates
Map entries = new TreeMap();
// save contained bundle packages
containedPackages.clear();
// empty stream used for folders
Resource folderResource = new ByteArrayResource(new byte[0]);
// add folder entries also
for (int i = 0; i < resources.length; i++) {
for (int j = 0; j < resources[i].length; j++) {
String relativeName = determineRelativeName(rootPath, resources[i][j]);
// be consistent when adding resources to jar
if (!relativeName.startsWith("/"))
relativeName = "/" + relativeName;
entries.put(relativeName, resources[i][j]);
// look for class entries
if (relativeName.endsWith(CLASS_EXT)) {
// determine package (exclude first char)
String clazzName = relativeName.substring(1, relativeName.length() - CLASS_EXT.length()).replace(
'/', '.');
// remove class name
int index = clazzName.lastIndexOf('.');
if (index > 0)
clazzName = clazzName.substring(0, index);
// add it to the collection
containedPackages.add(clazzName);
}
String token = relativeName;
// get folder and walk up to the root
if (addFolders) {
// add META-INF
entries.put("/META-INF/", folderResource);
int slashIndex;
// stop at root folder
while ((slashIndex = token.lastIndexOf('/')) > 1) {
// add the folder with trailing /
entries.put(token.substring(0, slashIndex + 1), folderResource);
// walk the tree
token = token.substring(0, slashIndex);
}
// add root folder
//entries.put("/", folderResource);
}
}
}
if (log.isTraceEnabled())
log.trace("The following packages were discovered in the bundle: " + containedPackages);
return entries;
}
public Collection getContainedPackages() {
return containedPackages;
}
/**
* @return Returns the contentPattern.
*/
public String[] getContentPattern() {
return contentPattern;
}
/**
* Pattern for content matching. Note that using {@link #EVERYTHING_PATTERN}
* can become problematic on windows due to file system locking.
*
* @param contentPattern The contentPattern to set.
*/
public void setContentPattern(String[] contentPattern) {
this.contentPattern = contentPattern;
}
/**
* @return Returns the patternResolver.
*/
public ResourcePatternResolver getPatternResolver() {
return patternResolver;
}
/**
* @param patternResolver The patternResolver to set.
*/
public void setPatternResolver(ResourcePatternResolver patternResolver) {
this.patternResolver = patternResolver;
}
/**
* @return Returns the jarStorage.
*/
public Storage getStorage() {
return storage;
}
/**
* @param jarStorage The jarStorage to set.
*/
public void setStorage(Storage jarStorage) {
this.storage = jarStorage;
}
/**
* @param
*/
public String getRootPath() {
return rootPath;
}
/**
* @param rootPath The rootPath to set.
*/
public void setRootPath(String rootPath) {
this.rootPath = rootPath;
}
/**
* @return Returns the addFolders.
*/
public boolean isAddFolders() {
return addFolders;
}
/**
* Whether the folders in which the files reside, should be added to the
* archive. Default is true since otherwise, the archive will contains only
* files and no folders.
*
* @param addFolders The addFolders to set.
*/
public void setAddFolders(boolean addFolders) {
this.addFolders = addFolders;
}
}