Plugin to validate all classes on the classpath are uniquely named

README.md

@@ -51,6 +51,7 @@ apply plugin: 'com.palantir.baseline-eclipse'
 apply plugin: 'com.palantir.baseline-idea'
 apply plugin: 'org.inferred.processors'  // installs the "processor" configuration needed for baseline-error-prone
 apply plugin: 'com.palantir.baseline-error-prone'
+apply plugin: 'com.palantir.baseline-class-uniqueness'
 ```
 
 - Run ``./gradlew baselineUpdateConfig`` to download the config files
@@ -255,6 +256,13 @@ checks](https://errorprone.info):
 - Slf4jLogsafeArgs: Allow only com.palantir.logsafe.Arg types as parameter inputs to slf4j log messages. More information on
 Safe Logging can be found at [github.com/palantir/safe-logging](https://github.com/palantir/safe-logging).
 
+
+### Class Uniqueness Plugin (com.palantir.baseline-class-uniqueness)
+
+Run `./gradlew checkClassUniqueness` to scan all jars on the `testRuntime` classpath for identically named classes.
+This task will run automatically as part of `./gradlew build`.
+
+
 ### Copyright Checks
 
 By default Baseline enforces Palantir copyright at the beginning of files. To change this, edit the template copyright

gradle-baseline-java/build.gradle

@@ -54,6 +54,10 @@ pluginBundle {
             id = 'com.palantir.baseline-idea'
             displayName = 'Palantir Baseline IntelliJ Plugin'
         }
+        baselineClassUniquenessPlugin {
+            id = 'com.palantir.baseline-class-uniqueness'
+            displayName = 'Palantir Baseline Class Uniqueness Plugin'
+        }
     }
 }
 

gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/Baseline.groovy

@@ -30,5 +30,8 @@ class Baseline implements Plugin<Project> {
         project.plugins.apply BaselineEclipse
         project.plugins.apply BaselineIdea
         project.plugins.apply BaselineErrorProne
+
+        // TODO(dfox): enable this when it has been validated on a few real projects
+        // project.plugins.apply BaselineClassUniquenessPlugin
     }
 }

gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineClassUniquenessPlugin.java

@@ -0,0 +1,34 @@
+/*
+ * (c) Copyright 2018 Palantir Technologies Inc. All rights reserved.
+ *
+ * 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 com.palantir.baseline.plugins;
+
+import com.palantir.baseline.tasks.CheckClassUniquenessTask;
+import org.gradle.api.Project;
+
+@SuppressWarnings("checkstyle:designforextension") // making this 'final' breaks gradle
+public class BaselineClassUniquenessPlugin extends AbstractBaselinePlugin {
+
+    @Override
+    public void apply(Project project) {
+        project.getPlugins().withId("java", plugin -> {
+            project.getTasks().create("checkClassUniqueness", CheckClassUniquenessTask.class, task -> {
+                task.setConfiguration(project.getConfigurations().getByName("runtime"));
+                project.getTasks().getByName("check").dependsOn(task);
+            });
+        });
+    }
+}

gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckClassUniquenessTask.java

@@ -0,0 +1,120 @@
+/*
+ * (c) Copyright 2018 Palantir Technologies Inc. All rights reserved.
+ *
+ * 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 com.palantir.baseline.tasks;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ModuleVersionIdentifier;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+
+@SuppressWarnings("checkstyle:designforextension") // making this 'final' breaks gradle
+public class CheckClassUniquenessTask extends DefaultTask {
+
+    private Configuration configuration;
+
+    public CheckClassUniquenessTask() {
+        setGroup("Verification");
+        setDescription("Checks that the given configuration contains no identically named classes.");
+    }
+
+    @Input
+    public Configuration getConfiguration() {
+        return configuration;
+    }
+
+    public void setConfiguration(Configuration configuration) {
+        this.configuration = configuration;
+    }
+
+    @TaskAction
+    public void checkForDuplicateClasses() {
+        ClassUniquenessAnalyzer analyzer = new ClassUniquenessAnalyzer(getLogger());
+        analyzer.analyzeConfiguration(getConfiguration());
+        boolean success = analyzer.getProblemJars().isEmpty();
+        writeResultFile(success);
+
+        if (!success) {
+            analyzer.getProblemJars().forEach((problemJars) -> {
+                Set<String> classes = analyzer.getDuplicateClassesInProblemJars(problemJars);
+                getLogger().error("Identically named classes found in {} jars ({}): {}",
+                        problemJars.size(), problemJars, classes);
+            });
+
+            throw new IllegalStateException(String.format(
+                    "'%s' contains multiple copies of identically named classes - "
+                            + "this may cause different runtime behaviour depending on classpath ordering.\n"
+                            + "To resolve this, try excluding one of the following jars, "
+                            + "changing a version or shadowing:\n\n%s",
+                    configuration.getName(),
+                    formatSummary(analyzer)
+            ));
+        }
+    }
+
+    private static String formatSummary(ClassUniquenessAnalyzer summary) {
+        int maxLength = summary.jarsToClasses().keySet().stream().flatMap(Set::stream)
+                .map(ModuleVersionIdentifier::toString)
+                .map(String::length)
+                .max(Comparator.naturalOrder()).get();
+        String format = "%-" + (maxLength + 1) + "s";
+
+        Map<String, Integer> sortedTable = summary.jarsToClasses().entrySet().stream().collect(Collectors.toMap(
+                entry -> entry.getKey().stream().map(jar -> String.format(format, jar)).collect(Collectors.joining()),
+                entry -> entry.getValue().size(),
+                (first, second) -> {
+                    throw new RuntimeException("Unexpected collision: " + first + ", " + second);
+                },
+                TreeMap::new));
+
+        StringBuilder builder = new StringBuilder();
+        sortedTable.forEach((jars, classes) ->
+                builder.append(String.format("\t%-14s", "(" + classes + " classes) ") + jars + "\n"));
+        return builder.toString();
+    }
+
+    /**
+     * This only exists to convince gradle this task is incremental.
+     */
+    @OutputFile
+    public File getResultFile() {
+        return getProject().getBuildDir().toPath()
+                .resolve(Paths.get("uniqueClassNames", configuration.getName()))
+                .toFile();
+    }
+
+    private void writeResultFile(boolean success) {
+        try {
+            File result = getResultFile();
+            Files.createDirectories(result.toPath().getParent());
+            Files.write(result.toPath(), Boolean.toString(success).getBytes(StandardCharsets.UTF_8));
+        } catch (IOException e) {
+            throw new RuntimeException("Unable to write boolean result file", e);
+        }
+    }
+}

gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/ClassUniquenessAnalyzer.java

@@ -0,0 +1,113 @@
+/*
+ * (c) Copyright 2018 Palantir Technologies Inc. All rights reserved.
+ *
+ * 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 com.palantir.baseline.tasks;
+
+import java.io.File;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ModuleVersionIdentifier;
+import org.gradle.api.artifacts.ResolvedArtifact;
+import org.slf4j.Logger;
+
+public final class ClassUniquenessAnalyzer {
+
+    private final Map<String, Set<ModuleVersionIdentifier>> classToJarsMap = new HashMap<>();
+    private final Map<Set<ModuleVersionIdentifier>, Set<String>> jarsToClasses = new HashMap<>();
+    private final Logger log;
+
+    public ClassUniquenessAnalyzer(Logger log) {
+        this.log = log;
+    }
+
+    public void analyzeConfiguration(Configuration configuration) {
+        Instant before = Instant.now();
+
+        Set<ResolvedArtifact> dependencies = configuration
+                .getResolvedConfiguration()
+                .getResolvedArtifacts();
+
+        Map<String, Set<ModuleVersionIdentifier>> tempClassToJarMap = new HashMap<>();
+        dependencies.stream().forEach(resolvedArtifact -> {
+            File file = resolvedArtifact.getFile();
+            if (!file.exists()) {
+                log.info("Skipping non-existent jar {}: {}", resolvedArtifact, file);
+                return;
+            }
+
+            try (JarFile jarFile = new JarFile(file)) {
+                Enumeration<JarEntry> entries = jarFile.entries();
+                while (entries.hasMoreElements()) {
+                    JarEntry jarEntry = entries.nextElement();
+
+                    if (!jarEntry.getName().endsWith(".class")) {
+                        continue;
+                    }
+
+                    multiMapPut(tempClassToJarMap,
+                            jarEntry.getName().replaceAll("/", ".").replaceAll(".class", ""),
+                            resolvedArtifact.getModuleVersion().getId());
+                }
+            } catch (Exception e) {
+                log.error("Failed to read JarFile {}", resolvedArtifact, e);
+                throw new RuntimeException(e);
+            }
+        });
+
+        tempClassToJarMap.entrySet().stream()
+                .filter(entry -> entry.getValue().size() > 1)
+                .forEach(entry -> {
+                    // add to the top level map
+                    entry.getValue().forEach(value -> multiMapPut(classToJarsMap, entry.getKey(), value));
+
+                    // add to the opposite direction index
+                    multiMapPut(jarsToClasses, entry.getValue(), entry.getKey());
+                });
+
+        Instant after = Instant.now();
+        log.info("Checked {} classes from {} dependencies for uniqueness ({}ms)",
+                tempClassToJarMap.size(), dependencies.size(), Duration.between(before, after).toMillis());
+    }
+
+    public Collection<Set<ModuleVersionIdentifier>> getProblemJars() {
+        return classToJarsMap.values();
+    }
+
+    public Map<Set<ModuleVersionIdentifier>, Set<String>> jarsToClasses() {
+        return jarsToClasses;
+    }
+
+    public Set<String> getDuplicateClassesInProblemJars(Set<ModuleVersionIdentifier> problemJars) {
+        return jarsToClasses.get(problemJars);
+    }
+
+    private static <K, V> void multiMapPut(Map<K, Set<V>> map, K key, V value) {
+        map.compute(key, (unused, collection) -> {
+            Set<V> newCollection = collection != null ? collection : new HashSet<>();
+            newCollection.add(value);
+            return newCollection;
+        });
+    }
+}

gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-class-uniqueness.properties

@@ -0,0 +1 @@
+implementation-class=com.palantir.baseline.plugins.BaselineClassUniquenessPlugin