Merge branch 'master' into remove-unused-variables

buildSrc/src/main/groovy/com/carrotsearch/gradle/junit4/RandomizedTestingPlugin.groovy

@@ -1,7 +1,6 @@
 package com.carrotsearch.gradle.junit4
 
 import com.carrotsearch.ant.tasks.junit4.JUnit4
-import org.gradle.api.GradleException
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.Task
@@ -11,12 +10,8 @@ import org.gradle.api.tasks.TaskContainer
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.testing.Test
 
-import java.util.concurrent.atomic.AtomicBoolean
-
 class RandomizedTestingPlugin implements Plugin<Project> {
 
-    static private AtomicBoolean sanityCheckConfigured = new AtomicBoolean(false)
-
     void apply(Project project) {
         setupSeed(project)
         replaceTestTask(project.tasks)
@@ -27,16 +22,10 @@ class RandomizedTestingPlugin implements Plugin<Project> {
     private static void configureSanityCheck(Project project) {
         // Check the task graph to confirm tasks were indeed replaced
         // https://github.com/elastic/elasticsearch/issues/31324
-        if (sanityCheckConfigured.getAndSet(true) == false) {
-            project.rootProject.getGradle().getTaskGraph().whenReady {
-                List<Task> nonConforming = project.getGradle().getTaskGraph().allTasks
-                        .findAll { it.name == "test" }
-                        .findAll { (it instanceof RandomizedTestingTask) == false}
-                        .collect { "${it.path} -> ${it.class}" }
-                if (nonConforming.isEmpty() == false) {
-                    throw new GradleException("Found the ${nonConforming.size()} `test` tasks:" +
-                            "\n  ${nonConforming.join("\n  ")}")
-                }
+        project.rootProject.getGradle().getTaskGraph().whenReady {
+            Task test = project.getTasks().findByName("test")
+            if (test != null && (test instanceof RandomizedTestingTask) == false) {
+                throw new IllegalStateException("Test task was not replaced in project ${project.path}. Found ${test.getClass()}")
             }
         }
     }

buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy

@@ -828,9 +828,6 @@ class BuildPlugin implements Plugin<Project> {
             // TODO: remove this once ctx isn't added to update script params in 7.0
             systemProperty 'es.scripting.update.ctx_in_params', 'false'
 
-            //TODO: remove this once the cname is prepended to the address by default in 7.0
-            systemProperty 'es.http.cname_in_publish_address', 'true'
-
             // Set the system keystore/truststore password if we're running tests in a FIPS-140 JVM
             if (project.inFipsJvm) {
                 systemProperty 'javax.net.ssl.trustStorePassword', 'password'

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

@@ -18,6 +18,7 @@
  */
 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
@@ -87,6 +88,11 @@ class PrecommitTasks {
     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
     }
 
@@ -205,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/java/org/elasticsearch/gradle/LoggedExec.java

@@ -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;
+        }
+    }
 }