| Methods Summary |
|---|
| public static java.lang.String | buildClassPathForEar(java.util.jar.JarFile ear)
return buildClassPathForEar(new Archive(ear));
|
| public static java.lang.String | buildClassPathForEar(java.io.File fileOrDir)
return buildClassPathForEar(new Archive(fileOrDir));
|
| public static java.lang.String | buildClassPathForEar(Archive jar)
logger.entering(myClassName, "buildClassPathForEar", jar);
StringBuffer classpath = new StringBuffer();
//See we do not care about bundled opt packages, as for an ear file
//there should not be any Class-Path entry.
ExtensionRef[] extRefs = jar.getExtensionRefs();
Archive[] allOptPkgs = Archive.getAllOptPkgsInstalledInJRE();
for (int i = 0; i < extRefs.length; ++i) {
ExtensionRef ref = extRefs[i];
logger.logp(Level.FINE, myClassName, "buildClassPathForEar",
"Finding an installed optional package matching extension ref\n" +
ref);
Archive satisfyingPkg = null;
for (int j = 0; j < allOptPkgs.length; ++j) {
if (ref.isSatisfiedBy(allOptPkgs[j])) {
satisfyingPkg = allOptPkgs[j];
break;
}
}
if (satisfyingPkg != null) {
logger.logp(Level.FINE, myClassName, "buildClassPathForEar",
"Found an installed optional package " +
satisfyingPkg.getPath());
if (classpath.length() != 0)
classpath.append(File.pathSeparator);
classpath.append(satisfyingPkg.getPath());
try {
String depCP = buildClassPathForJar(satisfyingPkg);
classpath.append(File.pathSeparator).append(depCP);
} catch (IOException e) {
logger.logp(Level.WARNING, myClassName,
"buildClassPathForEar",
"Ignoring " + satisfyingPkg.getPath(), e);
}
} else {
logger.logp(Level.WARNING, myClassName, "buildClassPathForEar",
"Could not find an installed optional package for \n" +
ref);
}
}//for each ref
File[] archives =
new File(jar.getPath()).listFiles(new FileFilter() {
public boolean accept(File pathname) {
return pathname.getName().endsWith("_rar");
}
});
for (File archive : archives) {
String rarCP = buildClassPathForRar(archive);
classpath.append(File.pathSeparator).append(rarCP);
}
String result = removeDuplicates(classpath).toString();
logger.exiting(myClassName, "buildClassPath", result);
return result;
|
| public static java.lang.String | buildClassPathForJar(java.util.jar.JarFile jar) // NOI18N
return buildClassPathForJar(new Archive(jar));
|
| public static java.lang.String | buildClassPathForJar(java.io.File file)
return buildClassPathForJar(new Archive(file));
|
| public static java.lang.String | buildClassPathForJar(Archive jar)
logger.entering(myClassName, "buildClassPathForJar", jar); // NOI18N
StringBuffer classpath = new StringBuffer(
jar.getPath() + File.pathSeparator);
Archive[] archives = jar.getBundledArchives();
classpath.append(convertToClassPath(archives));
//now resolve installed exts.
classpath.append(File.pathSeparator).append(
convertToClassPath(getInstalledArchivesForJar(jar)));
String result = removeDuplicates(classpath).toString();
logger.exiting(myClassName, "buildClassPathForJar", result); // NOI18N
return result;
|
| public static java.lang.String | buildClassPathForRar(java.io.File file)
return buildClassPathForRar(new Archive(file));
|
| public static java.lang.String | buildClassPathForRar(Archive rar)
logger.entering(myClassName, "buildClassPathForRar", rar); // NOI18N
final StringBuffer classpath = new StringBuffer();
// all the jar's inside the rar should be available in the classpath
new File(rar.getPath()).listFiles(new FileFilter() {
public boolean accept(File file) {
if (file.getName().endsWith(".jar") && file.isFile()) { // NOI18N
classpath.append(File.pathSeparator).append(file.getAbsolutePath());
return true;
}
return false;
}
});
Archive[] archives = rar.getBundledArchives();
classpath.append(convertToClassPath(archives));
//now resolve installed exts.
classpath.append(File.pathSeparator).append(
convertToClassPath(getInstalledArchivesForJar(rar)));
String result = removeDuplicates(classpath).toString();
logger.exiting(myClassName, "buildClassPathForRar", result); // NOI18N
return result;
|
| public static java.lang.String | buildClassPathForWar(java.util.jar.JarFile war)
return buildClassPathForWar(new Archive(war));
|
| public static java.lang.String | buildClassPathForWar(java.io.File file)
return buildClassPathForWar(new Archive(file));
|
| public static java.lang.String | buildClassPathForWar(Archive war)
final StringBuffer cp = new StringBuffer();
if (new File(war.getPath()).isDirectory()) {
final String explodedDir = war.getPath();
//As per section#9.5 of Servlet 2.4 spec, WEB-INF/classes must be
// ahead of WEB-INF/lib/*.jar in class-path.
cp.append(
explodedDir + File.separator + "WEB-INF" + File.separator +
"classes" +
File.separator);
File[] jarFiles = new File(
explodedDir + File.separator + "WEB-INF" + File.separator +
"lib").listFiles(new FileFilter() {
public boolean accept(File file) {
if (file.getName().endsWith(".jar") &&
file.isFile()) {
cp.append(File.pathSeparator).append(
file.getAbsolutePath());
return true;
}
return false;
}
});
} else {
assert(false);//We must explode the war. TBD. Anyway never reached from verifier.
}
Archive[] archives = war.getBundledArchives();
cp.append(File.pathSeparator).append(convertToClassPath(archives));
//now resolve installed exts.
cp.append(File.pathSeparator).append(
convertToClassPath(getInstalledArchivesForJar(war)));
String result = removeDuplicates(cp).toString();
logger.exiting(myClassName, "buildClassPathForWar", result);
return result;
|
| private static java.lang.StringBuffer | convertToClassPath(Archive[] archives)
StringBuffer cp = new StringBuffer();
for (int i = 0; i < archives.length; ++i) {
if (i != 0) cp.append(File.pathSeparatorChar);
cp.append(archives[i].getPath());
}
return cp;
|
| private static Archive[] | getInstalledArchivesForJar(Archive jar)
ArrayList<Archive> list = new ArrayList<Archive>();
ExtensionRef[] extRefs = jar.getExtensionRefs();
Archive[] bundled = jar.getBundledArchives();
Archive[] allOptPkgs = Archive.getAllOptPkgsInstalledInJRE();
//first go over all thebundled ones.
for (int i = 0; i < extRefs.length; ++i) {
ExtensionRef ref = extRefs[i];
logger.logp(Level.FINE, myClassName, "getInstalledArchivesForJar", // NOI18N
"Trying to find an optional package for \n" + ref); // NOI18N
logger.logp(Level.FINE, myClassName, "getInstalledArchivesForJar", // NOI18N
"Searching in the bundled optional package list."); // NOI18N
Archive satisfyingPkg = null;
for (int j = 0; j < bundled.length; ++j) {
try {
if (ref.isSatisfiedBy(bundled[j])) {
satisfyingPkg = bundled[j];
logger.logp(Level.INFO, myClassName,
"getInstalledArchivesForJar", // NOI18N
thisClassName + ".info1", new Object[]{satisfyingPkg.getPath()});
break;
}
} catch (IOException e) {
logger.logp(Level.WARNING, myClassName,
"getInstalledArchivesForJar", // NOI18N
thisClassName + ".exception1", new Object[]{bundled[j].getPath()});
logger.log(Level.WARNING, "", e);
}
}
logger.logp(Level.FINE, myClassName, "getInstalledArchivesForJar", // NOI18N
"Searching in the installed optional package list."); // NOI18N
//now go over installed refs.
if (satisfyingPkg == null) {
for (int j = 0; j < allOptPkgs.length; ++j) {
try {
if (ref.isSatisfiedBy(allOptPkgs[j])) {
satisfyingPkg = allOptPkgs[j];
logger.logp(Level.FINE, myClassName,
"buildClassPathForJar", // NOI18N
"Found a matching installed optional package " + // NOI18N
satisfyingPkg.getPath());
break;
}
} catch (IOException e) {
logger.logp(Level.WARNING, myClassName,
"getInstalledArchivesForJar", // NOI18N
thisClassName + ".exception1", new Object[]{allOptPkgs[j].getPath()});
logger.log(Level.WARNING, "", e);
}
}//for
}//if
if (satisfyingPkg != null) {
list.add(satisfyingPkg);
//TODO We are not supporting if the satisfyingPkg depends on some optional package.
} else {
logger.logp(Level.WARNING, myClassName, "buildClassPathForEar", thisClassName + ".warning1", new Object[]{ref.toString()});// NOI18N
}
}//for each ref
return (Archive[]) list.toArray(new Archive[0]);
|
| public static void | main(java.lang.String[] args)
if (args.length < 1) {
System.out.println(
"Usage : java " + ClassPathBuilder.class.getName() +
" <path(s) to jar files>");
}
Logger logger = Logger.getLogger("apiscan");
Handler h = new ConsoleHandler();
h.setLevel(Level.ALL);
logger.addHandler(h);
logger.setLevel(Level.ALL);
for (int i = 0; i < args.length; i++) {
String jarFileName = args[i];
try {
System.out.println("Building CLASSPATH for " + jarFileName);
String classPath;
if (jarFileName.endsWith(".ear"))
classPath =
ClassPathBuilder.buildClassPathForEar(
new Archive(new File(jarFileName)));
else
classPath =
ClassPathBuilder.buildClassPathForJar(
new Archive(new File(jarFileName)));
System.out.println(
"CLASSPATH for For " + jarFileName + "\n [" + classPath +
"]");
} catch (Exception e) {
System.out.println(
"For " + jarFileName + " got the following exception");
e.printStackTrace();
}
}
|
| private static java.lang.StringBuffer | removeDuplicates(java.lang.StringBuffer cp)
ArrayList<String> tokens = new ArrayList<String>();
for (StringTokenizer st = new StringTokenizer(cp.toString(),
File.pathSeparator);
st.hasMoreTokens();) {
String next = st.nextToken();
if (!tokens.contains(next)) tokens.add(next);
}
StringBuffer result = new StringBuffer();
for (int j = 0; j < tokens.size(); ++j) {
if (j != 0) result.append(File.pathSeparator);
result.append(tokens.get(j));
}
return result;
|
