zzh
/
gatk-3.8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New PackageUtils interferes with the packaging utility. Revert until Aaron and 

I can get together to make this work.


git-svn-id: file:///humgen/gsa-scr1/gsa-engineering/svn_contents/trunk@1957 348d0f76-0448-11de-a6fe-93d51630548a
This commit is contained in:
hanna 2009-11-02 19:14:14 +00:00
parent de6ae51f7e
commit 5a510e6d98
1 changed files with 8 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
java/src/org/broadinstitute/sting/utils/PackageUtils.java
View File

@ -3,30 +3,16 @@ package org.broadinstitute.sting.utils;
import org.reflections.Reflections;
import org.reflections.scanners.SubTypesScanner;
import org.reflections.util.AbstractConfiguration;
import org.apache.log4j.Logger;
import org.reflections.util.ClasspathHelper;
import java.util.Set;
import java.util.ArrayList;
import java.util.List;
import java.util.Collection;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.File;
import java.io.IOException;
import com.google.common.collect.Lists;
/**
* PackageUtils contains some useful methods for package introspection.
*/
public class PackageUtils {
/**
* our log, which we want to capture anything from this class
*/
private static Logger logger = Logger.getLogger(PackageUtils.class);
/**
* A reference into our introspection utility.
*/
@ -34,9 +20,9 @@ public class PackageUtils {
static {
// Initialize general-purpose source tree reflector.
reflections = new Reflections(new AbstractConfiguration() {
reflections = new Reflections( new AbstractConfiguration() {
{
setUrls(PackageUtils.getUrlsForClasspath(System.getProperty("java.class.path")));
setUrls(ClasspathHelper.getUrlsForCurrentClasspath());
setScanners(new SubTypesScanner());
}
});
@ -45,116 +31,25 @@ public class PackageUtils {
/**
* Private constructor. No instantiating this class!
*/
private PackageUtils() {
}
private PackageUtils() {}
{
}
/**
* Return the classes that implement the specified interface.
*
* @param iface the interface which returned classes should implement.
* @return the list of classes that implement the interface.
* @param iface the interface which returned classes should implement.
* @return the list of classes that implement the interface.
*/
public static <T> List<Class<? extends T>> getClassesImplementingInterface(Class<T> iface) {
// Load all classes implementing the given interface, then filter out any class that isn't concrete.
Set<Class<? extends T>> allTypes = reflections.getSubTypesOf(iface);
List<Class<? extends T>> concreteTypes = new ArrayList<Class<? extends T>>();
for (Class<? extends T> type : allTypes) {
if (JVMUtils.isConcrete(type))
for( Class<? extends T> type: allTypes ) {
if( JVMUtils.isConcrete(type) )
concreteTypes.add(type);
}
return concreteTypes;
}
/**
* get a list of URL's, given the current classpath. This function is a fix for the
* reflections package, which doesn't correctly expand the classpath from a jar (it doesn't
* get the manifest and parse out the embedded classpth).
* @param classpath the current classpath
* @return
*/
public static Collection<URL> getUrlsForClasspath(String classpath) {
// if the classpath is null, we can't really do anything
if (classpath == null || classpath.equals(""))
throw new StingException("Classpath cannot be empty or null");
List<URL> urls = Lists.newArrayList();
// the current working directory
String baseDir = System.getProperty("user.dir");
// our collection of classpath's to expand
List<JarPath> javaClassPath = new ArrayList<JarPath>();
// the current classpath can be a list of path's seperated by a semicolon
String[] classPaths = classpath.split(File.pathSeparator);
for (String part : classPaths) {
extractJarClasspath(baseDir, javaClassPath, part);
}
// check to make sure each extracted path exists, if so add it to our list
if (javaClassPath.size() > 0)
for (JarPath path : javaClassPath) {
try {
if (path.isValid())
urls.add(path.toValidFile().toURL());
} catch (MalformedURLException e) {
throw new StingException("could not create url from " + path, e);
}
}
return urls;
}
/**
* extract the classpath from a jar
*
* @param baseDir the base
* @param javaClassPath the list of jar paths
* @param part the current the subsection of the classpath we're processing
*/
private static void extractJarClasspath(String baseDir, List<JarPath> javaClassPath, String part) {
try {
JarFile myJar = new JarFile(part);
Attributes.Name classPath = new Attributes.Name("Class-Path");
if (myJar.getManifest().getMainAttributes().containsKey(classPath)) {
for (String jar : myJar.getManifest().getMainAttributes().getValue(classPath).split(" "))
javaClassPath.add(new JarPath(baseDir, new File(part).getParent(), jar));
}
} catch (IOException e) {
logger.warn("could not retreive manifest from " + part);
}
}
/**
* a simple helper class, to determine the absolute path to a jar file
*/
static class JarPath {
private final String mPath;
private final String mFilename;
private final String mWorkingDir;
public JarPath(String workingDir, String path, String filename) {
this.mPath = path;
this.mFilename = filename;
mWorkingDir = workingDir;
}
public File toValidFile() {
if (new File(mFilename).exists())
return new File(mFilename);
if (new File(mPath + File.separator + mFilename).exists())
return new File(mPath + File.separator + mFilename);
if (new File(mWorkingDir + File.separator + mFilename).exists())
return new File(mWorkingDir + File.separator + mFilename);
return null;
}
public boolean isValid() {
return (toValidFile() != null) ? true : false;
}
}
}