/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package vogar;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import vogar.commands.Mkdir;
import vogar.util.Strings;
/**
* Indexes the locations of commonly used classes to assist in constructing correct Vogar commands.
*/
public final class ClassFileIndex {
/** how many milliseconds before the cache expires and we reindex jars */
private static final long CACHE_EXPIRY = 86400000; // = one day
/** regular expressions representing things that make sense on the classpath */
private static final List<String> JAR_PATTERN_STRINGS = Arrays.asList(
"classes\\.jar"
);
/** regular expressions representing failures probably due to things missing on the classpath */
private static final List<String> FAILURE_PATTERN_STRINGS = Arrays.asList(
".*package (.*) does not exist.*",
".*import (.*);.*",
".*ClassNotFoundException: (\\S*).*",
".*NoClassDefFoundError: Could not initialize class (\\S*).*"
);
private static final List<Pattern> JAR_PATTERNS = new ArrayList<Pattern>();
static {
for (String patternString : JAR_PATTERN_STRINGS) {
JAR_PATTERNS.add(Pattern.compile(patternString));
}
}
private static final List<Pattern> FAILURE_PATTERNS = new ArrayList<Pattern>();
static {
for (String patternString : FAILURE_PATTERN_STRINGS) {
// DOTALL flag allows proper handling of multiline strings
FAILURE_PATTERNS.add(Pattern.compile(patternString, Pattern.DOTALL));
}
}
private final Log log;
private final Mkdir mkdir;
private final String DELIMITER = "\t";
private final File classFileIndexFile =
new File(System.getProperty("user.home"), ".vogar/classfileindex");
private final Map<String, Set<File>> classFileMap = new HashMap<String, Set<File>>();
private final List<File> jarSearchDirs;
public ClassFileIndex(Log log, Mkdir mkdir, List<File> jarSearchDirs) {
this.log = log;
this.mkdir = mkdir;
this.jarSearchDirs = jarSearchDirs;
}
public Set<File> suggestClasspaths(String testOutput) {
Set<File> suggestedClasspaths = new HashSet<File>();
for (Pattern pattern : FAILURE_PATTERNS) {
Matcher matcher = pattern.matcher(testOutput);
if (!matcher.matches()) {
continue;
}
for (int i = 1; i <= matcher.groupCount(); i++) {
String missingPackageOrClass = matcher.group(i);
Set<File> containingJars = classFileMap.get(missingPackageOrClass);
if (containingJars != null) {
suggestedClasspaths.addAll(containingJars);
}
}
}
return suggestedClasspaths;
}
/**
* Search through the jar search directories to find .jars to index.
*
* If this has already been done, instead just use the cached version in .vogar
*/
public void createIndex() {
if (!classFileMap.isEmpty()) {
return;
}
if (classFileIndexFile.exists()) {
long lastModified = classFileIndexFile.lastModified();
long curTime = new Date().getTime();
boolean cacheExpired = lastModified < curTime - CACHE_EXPIRY;
if (cacheExpired) {
log.verbose("class file index expired, rebuilding");
} else {
readIndexCache();
return;
}
}
log.verbose("building class file index");
// Create index
for (File jarSearchDir : jarSearchDirs) {
if (!jarSearchDir.exists()) {
log.warn("directory \"" + jarSearchDir + "\" in jar paths doesn't exist");
continue;
}
// traverse the jar directory, looking for files called ending in .jar
log.verbose("looking in " + jarSearchDir + " for .jar files");
Set<File> jarFiles = new HashSet<File>();
getJarFiles(jarFiles, jarSearchDir);
for (File file : jarFiles) {
indexJarFile(file);
}
}
// save for use on subsequent runs
writeIndexCache();
}
private void indexJarFile(File file) {
try {
JarFile jarFile = new JarFile(file);
for (Enumeration<JarEntry> e = jarFile.entries(); e.hasMoreElements(); ) {
JarEntry jarEntry = e.nextElement();
// change paths into classes/packages, strip trailing period, and strip
// trailing .class extension
String classPath = jarEntry.getName()
.replaceAll("/", ".")
.replaceFirst("\\.$", "")
.replaceFirst("\\.class$", "");
if (classFileMap.containsKey(classPath)) {
classFileMap.get(classPath).add(file);
} else {
Set<File> classPathJars = new HashSet<File>();
classPathJars.add(file);
classFileMap.put(classPath, classPathJars);
}
}
} catch (IOException e) {
log.warn("failed to read " + file + ": " + e.getMessage());
}
}
private void getJarFiles(Set<File> jarFiles, File dir) {
List<File> files = Arrays.asList(dir.listFiles());
for (File file : files) {
if (file.isDirectory() && file.exists() && file.canRead()) {
getJarFiles(jarFiles, file);
continue;
}
for (Pattern pattern : JAR_PATTERNS) {
Matcher matcher = pattern.matcher(file.getName());
if (matcher.matches()) {
jarFiles.add(file);
}
}
}
}
private void writeIndexCache() {
log.verbose("writing index cache");
BufferedWriter indexCacheWriter;
mkdir.mkdirs(classFileIndexFile.getParentFile());
try {
indexCacheWriter = new BufferedWriter(new FileWriter(classFileIndexFile));
for (Map.Entry<String, Set<File>> entry : classFileMap.entrySet()) {
indexCacheWriter.write(entry.getKey() + DELIMITER
+ Strings.join(entry.getValue(), DELIMITER));
indexCacheWriter.newLine();
}
indexCacheWriter.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private void readIndexCache() {
log.verbose("reading class file index cache");
BufferedReader reader;
try {
reader = new BufferedReader(new FileReader(classFileIndexFile));
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
try {
String line;
while ((line = reader.readLine()) != null) {
line = line.trim();
// Each line is a mapping of a class, package or file to the .jar files that
// contain its definition within VOGAR_JAR_PATH. Each component is separated
// by a delimiter.
String[] parts = line.split(DELIMITER);
if (parts.length < 2) {
throw new RuntimeException("classfileindex contains invalid line: " + line);
}
String resource = parts[0];
Set<File> jarFiles = new HashSet<File>();
for (int i = 1; i < parts.length; i++) {
jarFiles.add(new File(parts[i]));
}
classFileMap.put(resource, jarFiles);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}