src/vogar/ClassFileIndex.java - platform/external/vogar - Git at Google

 /*
  * 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);
         }
     }
 }
	/*
	* 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);
	}
	}
	}