Merge remote-tracking branch 'es/master' into ccr_autofollow_coordinator_stats

Author: martijnvg

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/JarHellTask.groovy

@@ -18,10 +18,10 @@
  */
 package org.elasticsearch.gradle.precommit
 
+import com.github.jengelman.gradle.plugins.shadow.ShadowPlugin
 import org.elasticsearch.gradle.ExportElasticsearchBuildResourcesTask
 import org.gradle.api.Project
 import org.gradle.api.Task
-import org.gradle.api.artifacts.Configuration
 import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.plugins.quality.Checkstyle
 /**
@@ -70,19 +70,29 @@ class PrecommitTasks {
             precommitTasks.add(configureLoggerUsage(project))
         }
 
+        // We want to get any compilation error before running the pre-commit checks.
+        project.sourceSets.all { sourceSet ->
+            precommitTasks.each { task ->
+                task.shouldRunAfter(sourceSet.getClassesTaskName())
+            }
+        }
 
-        Map<String, Object> precommitOptions = [
+        return project.tasks.create([
             name: 'precommit',
             group: JavaBasePlugin.VERIFICATION_GROUP,
             description: 'Runs all non-test checks.',
             dependsOn: precommitTasks
-        ]
-        return project.tasks.create(precommitOptions)
+        ])
     }
 
     private static Task configureJarHell(Project project) {
         Task task = project.tasks.create('jarHell', JarHellTask.class)
         task.classpath = project.sourceSets.test.runtimeClasspath
+        if (project.plugins.hasPlugin(ShadowPlugin)) {
+            task.classpath += project.configurations.bundle
+        }
+        task.dependsOn(project.sourceSets.test.classesTaskName)
+        task.javaHome = project.runtimeJavaHome
         return task
     }
 
@@ -201,22 +211,20 @@ class PrecommitTasks {
 
     private static Task configureNamingConventions(Project project) {
         if (project.sourceSets.findByName("test")) {
-            return project.tasks.create('namingConventions', NamingConventionsTask)
+            Task namingConventionsTask = project.tasks.create('namingConventions', NamingConventionsTask)
+            namingConventionsTask.javaHome = project.runtimeJavaHome
+            return namingConventionsTask
         }
         return null
     }
 
     private static Task configureLoggerUsage(Project project) {
-        Task loggerUsageTask = project.tasks.create('loggerUsageCheck', LoggerUsageTask.class)
-
         project.configurations.create('loggerUsagePlugin')
         project.dependencies.add('loggerUsagePlugin',
                 "org.elasticsearch.test:logger-usage:${org.elasticsearch.gradle.VersionProperties.elasticsearch}")
-
-        loggerUsageTask.configure {
+        return project.tasks.create('loggerUsageCheck', LoggerUsageTask.class) {
             classpath = project.configurations.loggerUsagePlugin
+            javaHome = project.runtimeJavaHome
         }
-
-        return loggerUsageTask
     }
 }

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/LoggerUsageTask.groovy

@@ -1,20 +1,26 @@
 package org.elasticsearch.gradle;
 
+import org.gradle.api.Action;
 import org.gradle.api.GradleException;
+import org.gradle.api.Project;
 import org.gradle.api.tasks.Exec;
+import org.gradle.process.BaseExecSpec;
+import org.gradle.process.ExecResult;
+import org.gradle.process.ExecSpec;
+import org.gradle.process.JavaExecSpec;
 
 import java.io.ByteArrayOutputStream;
 import java.io.UnsupportedEncodingException;
+import java.util.function.Function;
 
 /**
  * A wrapper around gradle's Exec task to capture output and log on error.
  */
 @SuppressWarnings("unchecked")
 public class LoggedExec extends Exec {
 
-    protected ByteArrayOutputStream output = new ByteArrayOutputStream();
-
     public LoggedExec() {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
         if (getLogger().isInfoEnabled() == false) {
             setStandardOutput(output);
             setErrorOutput(output);
@@ -41,4 +47,39 @@ public LoggedExec() {
             );
         }
     }
+
+    public static ExecResult exec(Project project, Action<ExecSpec> action) {
+        return genericExec(project, project::exec, action);
+    }
+
+    public static ExecResult javaexec(Project project, Action<JavaExecSpec> action) {
+        return genericExec(project, project::javaexec, action);
+    }
+
+    private static <T extends BaseExecSpec>  ExecResult genericExec(
+        Project project,
+        Function<Action<T>,ExecResult> function,
+        Action<T> action
+    ) {
+        if (project.getLogger().isInfoEnabled()) {
+            return function.apply(action);
+        }
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        try {
+            return function.apply(spec -> {
+                spec.setStandardOutput(output);
+                spec.setErrorOutput(output);
+                action.execute(spec);
+            });
+        } catch (Exception e) {
+            try {
+                for (String line : output.toString("UTF-8").split("\\R")) {
+                    project.getLogger().error(line);
+                }
+            } catch (UnsupportedEncodingException ue) {
+                throw new GradleException("Failed to read exec output", ue);
+            }
+            throw e;
+        }
+    }
 }

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/PrecommitTasks.groovy

@@ -18,30 +18,26 @@
  */
 package org.elasticsearch.gradle.precommit;
 
-import org.gradle.api.DefaultTask;
+import org.elasticsearch.gradle.LoggedExec;
 import org.gradle.api.JavaVersion;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.InputFiles;
-import org.gradle.api.tasks.OutputFile;
 import org.gradle.api.tasks.SkipWhenEmpty;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.TaskAction;
 import org.gradle.process.JavaExecSpec;
 
 import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
-public class ForbiddenApisCliTask extends DefaultTask {
+public class ForbiddenApisCliTask extends PrecommitTask {
 
     private final Logger logger = Logging.getLogger(ForbiddenApisCliTask.class);
     private FileCollection signaturesFiles;
@@ -71,14 +67,6 @@ public void setTargetCompatibility(JavaVersion targetCompatibility) {
         }
     }
 
-    @OutputFile
-    public File getMarkerFile() {
-        return new File(
-            new File(getProject().getBuildDir(), "precommit"),
-            getName()
-        );
-    }
-
     @InputFiles
     @SkipWhenEmpty
     public FileCollection getClassesDirs() {
@@ -152,8 +140,8 @@ public void setJavaHome(Object javaHome) {
     }
 
     @TaskAction
-    public void runForbiddenApisAndWriteMarker() throws IOException {
-        getProject().javaexec((JavaExecSpec spec) -> {
+    public void runForbiddenApisAndWriteMarker() {
+        LoggedExec.javaexec(getProject(), (JavaExecSpec spec) -> {
             spec.classpath(
                 getForbiddenAPIsConfiguration(),
                 getClassPathFromSourceSet()
@@ -184,7 +172,6 @@ public void runForbiddenApisAndWriteMarker() throws IOException {
                 spec.args("-d", dir)
             );
         });
-        Files.write(getMarkerFile().toPath(), Collections.emptyList());
     }
 
 }