ClasspathDescriptor.java
/*
* 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 org.basepom.mojo.duplicatefinder.classpath;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static java.lang.String.format;
import org.basepom.mojo.duplicatefinder.ConflictType;
import org.basepom.mojo.duplicatefinder.artifact.MavenCoordinates;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import javax.lang.model.SourceVersion;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.MultimapBuilder;
import com.google.common.io.Files;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.project.MavenProject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@SuppressFBWarnings("NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE")
public final class ClasspathDescriptor {
private static final Logger LOG = LoggerFactory.getLogger(ClasspathDescriptor.class);
private static final MatchPatternPredicate DEFAULT_IGNORED_RESOURCES_PREDICATE = new MatchPatternPredicate(Arrays.asList(
// Standard jar folders
"^META-INF/.*",
"^OSGI-INF/.*",
// directory name that shows up all the time
"^licenses/.*",
// file names that show up all the time
".*license(\\.txt)?$",
".*notice(\\.txt)?$",
".*readme(\\.txt)?$",
".*changelog(\\.txt)?$",
".*third-party(\\.txt)?$",
// HTML stuff from javadocs.
".*package\\.html$",
".*overview\\.html$"));
@VisibleForTesting
static final MatchPatternPredicate DEFAULT_IGNORED_CLASS_PREDICATE = new MatchPatternPredicate(Arrays.asList(
"^(.*\\.)?.*\\$.*$", // matches inner classes in any package
"^(.*\\.)?package-info$", // matches package-info in any package
"^(.*\\.)?module-info$" // matches module-info in any package
));
private static final MatchPatternPredicate DEFAULT_IGNORED_LOCAL_DIRECTORIES = new MatchPatternPredicate(Arrays.asList(
"^.git$",
"^.svn$",
"^.hg$",
"^.bzr$"));
/**
* This is a global, static cache which can be reused through multiple runs of the plugin in the same VM, e.g. for a multi-module build.
*/
private static final ConcurrentMap<File, ClasspathCacheElement> CACHED_BY_FILE = new ConcurrentHashMap<>();
private final Multimap<String, File> classesWithElements = MultimapBuilder.treeKeys().hashSetValues().build();
private final Multimap<String, File> resourcesWithElements = MultimapBuilder.treeKeys().hashSetValues().build();
private final Predicate<String> resourcesPredicate;
private final Predicate<String> classPredicate;
private final ImmutableList<Pattern> ignoredResourcePatterns;
private final ImmutableList<Pattern> ignoredClassPatterns;
public static ClasspathDescriptor createClasspathDescriptor(final MavenProject project,
final Multimap<File, Artifact> fileToArtifactMap,
final Collection<String> ignoredResourcePatterns,
final Collection<String> ignoredClassPatterns,
final Collection<MavenCoordinates> ignoredDependencies,
final boolean useDefaultResourceIgnoreList,
final boolean useDefaultClassIgnoreList,
final File... projectFolders) throws MojoExecutionException {
checkNotNull(project, "project is null");
checkNotNull(fileToArtifactMap, "fileToArtifactMap is null");
checkNotNull(ignoredResourcePatterns, "ignoredResourcePatterns is null");
checkNotNull(ignoredClassPatterns, "ignoredClassPatterns is null");
checkNotNull(ignoredDependencies, "ignoredDependencies is null");
checkNotNull(projectFolders, "projectFolders is null");
final ClasspathDescriptor classpathDescriptor = new ClasspathDescriptor(useDefaultResourceIgnoreList, ignoredResourcePatterns,
useDefaultClassIgnoreList, ignoredClassPatterns);
File file = null;
final MatchArtifactPredicate matchArtifactPredicate = new MatchArtifactPredicate(ignoredDependencies);
Artifact artifact = null;
try {
// any entry is either a jar in the repo or a folder in the target folder of a referenced
// project. Add the elements that are not ignored by the ignoredDependencies predicate to
// the classpath descriptor.
for (final Entry<File, Artifact> entry : fileToArtifactMap.entries()) {
artifact = entry.getValue();
file = entry.getKey();
if (file.exists()) {
// Add to the classpath if the artifact predicate does not apply (then it is not in the ignoredDependencies list).
if (!matchArtifactPredicate.apply(artifact)) {
classpathDescriptor.addClasspathElement(file);
}
} else {
// e.g. when running the goal explicitly on a cleaned multi-module project, referenced
// projects will try to use the output folders of a referenced project but these do not
// exist. Obviously, in this case the plugin might return incorrect results (unfortunately
// false negatives, but there is not much it can do here (besides fail the build here with a
// cryptic error message. Maybe add a flag?).
LOG.debug(format("Classpath element '%s' does not exist.", file.getAbsolutePath()));
}
}
} catch (final IOException ex) {
throw new MojoExecutionException(format("Error trying to access file '%s' for artifact '%s'", file, artifact), ex);
}
try {
// Add project folders unconditionally.
for (final File projectFile : projectFolders) {
file = projectFile;
if (projectFile.exists()) {
classpathDescriptor.addClasspathElement(file);
} else {
// See above. This may happen in the project has been cleaned before running the goal directly.
LOG.debug(format("Project folder '%s' does not exist.", file.getAbsolutePath()));
}
}
} catch (final IOException ex) {
throw new MojoExecutionException(format("Error trying to access project folder '%s'", file), ex);
}
return classpathDescriptor;
}
private ClasspathDescriptor(final boolean useDefaultResourceIgnoreList,
final Collection<String> ignoredResourcePatterns,
final boolean useDefaultClassIgnoreList,
final Collection<String> ignoredClassPatterns)
throws MojoExecutionException {
final Builder<Pattern> ignoredResourcePatternsBuilder = ImmutableList.builder();
// build resource predicate...
Predicate<String> resourcesPredicate = s -> false;
// predicate matching the default ignores
if (useDefaultResourceIgnoreList) {
resourcesPredicate = resourcesPredicate.or(DEFAULT_IGNORED_RESOURCES_PREDICATE);
ignoredResourcePatternsBuilder.addAll(DEFAULT_IGNORED_RESOURCES_PREDICATE.getPatterns());
}
if (!ignoredResourcePatterns.isEmpty()) {
try {
// predicate matching the user ignores
MatchPatternPredicate ignoredResourcesPredicate = new MatchPatternPredicate(ignoredResourcePatterns);
resourcesPredicate = resourcesPredicate.or(ignoredResourcesPredicate);
ignoredResourcePatternsBuilder.addAll(ignoredResourcesPredicate.getPatterns());
} catch (final PatternSyntaxException pse) {
throw new MojoExecutionException("Error compiling resourceIgnore pattern: " + pse.getMessage());
}
}
this.resourcesPredicate = resourcesPredicate;
this.ignoredResourcePatterns = ignoredResourcePatternsBuilder.build();
final Builder<Pattern> ignoredClassPatternsBuilder = ImmutableList.builder();
// build class predicate.
Predicate<String> classPredicate = s -> false;
// predicate matching the default ignores
if (useDefaultClassIgnoreList) {
classPredicate = classPredicate.or(DEFAULT_IGNORED_CLASS_PREDICATE);
ignoredClassPatternsBuilder.addAll(DEFAULT_IGNORED_CLASS_PREDICATE.getPatterns());
}
if (!ignoredClassPatterns.isEmpty()) {
try {
// predicate matching the user ignores
MatchPatternPredicate ignoredPackagePredicate = new MatchPatternPredicate(ignoredClassPatterns);
classPredicate = classPredicate.or(ignoredPackagePredicate);
ignoredClassPatternsBuilder.addAll(ignoredPackagePredicate.getPatterns());
} catch (final PatternSyntaxException pse) {
throw new MojoExecutionException("Error compiling classIgnore pattern: " + pse.getMessage());
}
}
this.classPredicate = classPredicate;
this.ignoredClassPatterns = ignoredClassPatternsBuilder.build();
}
public ImmutableMap<String, Collection<File>> getClasspathElementLocations(final ConflictType type) {
checkNotNull(type, "type is null");
switch (type) {
case CLASS:
return ImmutableMultimap.copyOf(classesWithElements).asMap();
case RESOURCE:
return ImmutableMultimap.copyOf(resourcesWithElements).asMap();
default:
throw new IllegalStateException("Type '" + type + "' unknown!");
}
}
public ImmutableList<Pattern> getIgnoredResourcePatterns() {
return ignoredResourcePatterns;
}
public ImmutableList<Pattern> getIgnoredClassPatterns() {
return ignoredClassPatterns;
}
public ImmutableList<Pattern> getIgnoredDirectoryPatterns() {
return DEFAULT_IGNORED_LOCAL_DIRECTORIES.getPatterns();
}
private void addClasspathElement(final File element) throws IOException {
checkState(element.exists(), "Path '%s' does not exist!", element.getAbsolutePath());
ClasspathCacheElement cached = CACHED_BY_FILE.get(element);
if (cached == null) {
final ClasspathCacheElement.Builder cacheBuilder = ClasspathCacheElement.builder(element);
if (element.isDirectory()) {
addDirectory(cacheBuilder, element, new PackageNameHolder());
} else {
addArchive(cacheBuilder, element);
}
final ClasspathCacheElement newCached = cacheBuilder.build();
final ClasspathCacheElement oldCached = CACHED_BY_FILE.putIfAbsent(element, newCached);
cached = MoreObjects.firstNonNull(oldCached, newCached);
} else {
LOG.debug(format("Cache hit for '%s'", element.getAbsolutePath()));
}
cached.putResources(resourcesWithElements, resourcesPredicate);
cached.putClasses(classesWithElements, classPredicate);
}
private void addDirectory(final ClasspathCacheElement.Builder cacheBuilder, final File workDir, final PackageNameHolder packageName) {
final File[] files = workDir.listFiles();
if (files != null) {
for (final File file : files) {
if (file.isDirectory()) {
if (DEFAULT_IGNORED_LOCAL_DIRECTORIES.apply(file.getName())) {
LOG.debug(format("Ignoring local directory '%s'", file.getAbsolutePath()));
} else {
addDirectory(cacheBuilder, file, packageName.getChildPackage(file.getName()));
}
} else if (file.isFile()) {
if ("class".equals(Files.getFileExtension(file.getName()))) {
final String className = packageName.getQualifiedName(Files.getNameWithoutExtension(file.getName()));
cacheBuilder.addClass(className);
} else {
final String resourcePath = packageName.getQualifiedPath(file.getName());
cacheBuilder.addResource(resourcePath);
}
} else {
LOG.warn(format("Ignoring unknown file type for '%s'", file.getAbsolutePath()));
}
}
}
}
private void addArchive(final ClasspathCacheElement.Builder cacheBuilder, final File element) throws IOException {
try (
InputStream input = element.toURI().toURL().openStream();
ZipInputStream zipInput = new ZipInputStream(input)) {
ZipEntry entry;
while ((entry = zipInput.getNextEntry()) != null) {
if (!entry.isDirectory()) {
final String name = entry.getName();
Optional<List<String>> validatedElements = validateClassName(name);
if (validatedElements.isPresent()) {
List<String> nameElements = validatedElements.get();
final PackageNameHolder packageName = new PackageNameHolder(nameElements.subList(0, nameElements.size() - 1));
final String className = packageName.getQualifiedName(Files.getNameWithoutExtension(name));
cacheBuilder.addClass(className);
} else {
final String resourcePath = name.replace('\\', File.separatorChar);
cacheBuilder.addResource(resourcePath);
}
}
}
}
}
@VisibleForTesting
static Optional<List<String>> validateClassName(String fullClassPath) {
if (fullClassPath == null) {
return Optional.empty();
}
// ZIP/Jars always use "/" as separators
final List<String> nameElements = ImmutableList.copyOf(Splitter.on("/").splitToList(fullClassPath));
if (nameElements.isEmpty()) {
LOG.warn(format("ZIP entry '%s' split into empty list!", fullClassPath));
return Optional.empty();
}
String classFileName = nameElements.get(nameElements.size() - 1);
if (!"class".equals(Files.getFileExtension(classFileName))) {
LOG.debug(format("Ignoring %s, %s is not a class file", fullClassPath, classFileName));
return Optional.empty();
}
for (int i = 0; i < nameElements.size() - 1; i++) {
if (!SourceVersion.isIdentifier(nameElements.get(i))) {
LOG.debug(format("Ignoring %s, %s is not a valid package element", fullClassPath, nameElements.get(i)));
return Optional.empty();
}
}
String className = Files.getNameWithoutExtension(classFileName);
if (!(SourceVersion.isIdentifier(className)
|| "module-info".equals(className)
|| "package-info".equals(className))) {
LOG.debug(format("Ignoring %s, %s is not a valid class identifier", fullClassPath, className));
return Optional.empty();
}
return Optional.of(nameElements);
}
}