Use bundled jdk as default runtime jdk instead of build jvm (#111197)

* Fallback to bundled jdk for runtime jdk instead of build jvm
* Rework bundled jdk resolution to be lazy
* Use fixed runtime jdk for gradle build integ tests

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/fixtures/AbstractGradleInternalPluginFuncTest.groovy

@@ -15,6 +15,12 @@ abstract class AbstractGradleInternalPluginFuncTest extends AbstractJavaGradleFu
     abstract <T extends Plugin> Class<T> getPluginClassUnderTest();
 
     def setup() {
+        settingsFile.text = """
+        plugins {
+            id 'elasticsearch.java-toolchain'
+        }
+        """ + settingsFile.text
+
         buildFile << """
         import ${getPluginClassUnderTest().getName()}
 

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/ElasticsearchJavadocPluginFuncTest.groovy

@@ -66,6 +66,7 @@ class ElasticsearchJavadocPluginFuncTest extends AbstractGradleFuncTest {
 
     def "sources of shadowed dependencies are added to projects javadoc"() {
         given:
+        settingsFile.text = ""
         someLibProject() << """version = 1.0"""
         subProject("some-depending-lib") {
             buildFile << """

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/precommit/ThirdPartyAuditTaskFuncTest.groovy

@@ -18,6 +18,7 @@ import org.elasticsearch.gradle.fixtures.AbstractGradleFuncTest
 import org.elasticsearch.gradle.fixtures.AbstractGradleInternalPluginFuncTest
 import org.elasticsearch.gradle.internal.conventions.precommit.LicenseHeadersPrecommitPlugin
 import org.elasticsearch.gradle.internal.conventions.precommit.PrecommitPlugin
+import org.gradle.testkit.runner.GradleRunner
 import org.gradle.testkit.runner.TaskOutcome
 
 
@@ -211,6 +212,10 @@ class ThirdPartyAuditTaskFuncTest extends AbstractGradleInternalPluginFuncTest {
         loggingDynamicType.toJar(targetFile(dir("${baseGroupFolderPath}/broken-log4j/0.0.1/"), "broken-log4j-0.0.1.jar"))
     }
 
+    GradleRunner gradleRunner(Object... arguments) {
+        return super.gradleRunner(arguments).withEnvironment([RUNTIME_JAVA_HOME: System.getProperty("java.home")])
+    }
+
     static File targetFile(File dir, String fileName) {
         new File(dir, fileName)
     }

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/test/rest/LegacyYamlRestTestPluginFuncTest.groovy

@@ -12,6 +12,7 @@ import spock.lang.IgnoreIf
 
 import org.elasticsearch.gradle.VersionProperties
 import org.elasticsearch.gradle.fixtures.AbstractRestResourcesFuncTest
+import org.gradle.testkit.runner.GradleRunner
 import org.gradle.testkit.runner.TaskOutcome
 
 @IgnoreIf({ os.isWindows() })
@@ -205,4 +206,8 @@ echo "Running elasticsearch \$0"
             }
         """
     }
+
+    GradleRunner gradleRunner(Object... arguments) {
+        return super.gradleRunner(arguments).withEnvironment([RUNTIME_JAVA_HOME: System.getProperty("java.home")])
+    }
 }

build-tools-internal/src/main/groovy/elasticsearch.runtime-jdk-provision.gradle

@@ -25,7 +25,6 @@ configure(allprojects) {
         JvmVendorSpec.ORACLE :
         JvmVendorSpec.matching(VersionProperties.bundledJdkVendor)
     }
-
   project.tasks.withType(Test).configureEach { Test test ->
         if (BuildParams.getIsRuntimeJavaHomeSet()) {
             test.executable = "${BuildParams.runtimeJavaHome}/bin/java" +
@@ -47,12 +46,4 @@ configure(allprojects) {
             }
         }
     }
-    project.plugins.withType(ThirdPartyAuditPrecommitPlugin) {
-      project.getTasks().withType(ThirdPartyAuditTask.class).configureEach {
-        if (BuildParams.getIsRuntimeJavaHomeSet() == false) {
-          javaHome.set(launcher.map { it.metadata.installationPath.asFile.path })
-          targetCompatibility.set(providers.provider(() -> JavaVersion.toVersion(launcher.map { it.metadata.javaRuntimeVersion }.get())))
-        }
-      }
-    }
 }

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/info/BuildParams.java

@@ -26,15 +26,15 @@ import java.util.function.Consumer;
 import static java.util.Objects.requireNonNull;
 
 public class BuildParams {
-    private static File runtimeJavaHome;
+    private static Provider<File> runtimeJavaHome;
     private static Boolean isRuntimeJavaHomeSet;
     private static List<JavaHome> javaVersions;
     private static JavaVersion minimumCompilerVersion;
     private static JavaVersion minimumRuntimeVersion;
     private static JavaVersion gradleJavaVersion;
-    private static JavaVersion runtimeJavaVersion;
+    private static Provider<JavaVersion> runtimeJavaVersion;
     private static Provider<? extends Action<JavaToolchainSpec>> javaToolChainSpec;
-    private static String runtimeJavaDetails;
+    private static Provider<String> runtimeJavaDetails;
     private static Boolean inFipsJvm;
     private static String gitRevision;
     private static String gitOrigin;
@@ -58,7 +58,7 @@ public class BuildParams {
     }
 
     public static File getRuntimeJavaHome() {
-        return value(runtimeJavaHome);
+        return value(runtimeJavaHome).get();
     }
 
     public static Boolean getIsRuntimeJavaHomeSet() {
@@ -82,11 +82,11 @@ public class BuildParams {
     }
 
     public static JavaVersion getRuntimeJavaVersion() {
-        return value(runtimeJavaVersion);
+        return value(runtimeJavaVersion.get());
     }
 
     public static String getRuntimeJavaDetails() {
-        return value(runtimeJavaDetails);
+        return value(runtimeJavaDetails.get());
     }
 
     public static Boolean isInFipsJvm() {
@@ -126,7 +126,7 @@ public class BuildParams {
     }
 
     public static Boolean isGraalVmRuntime() {
-        return value(runtimeJavaDetails.toLowerCase().contains("graalvm"));
+        return value(runtimeJavaDetails.get().toLowerCase().contains("graalvm"));
     }
 
     public static Integer getDefaultParallel() {
@@ -182,16 +182,18 @@ public class BuildParams {
             });
         }
 
-        public void setRuntimeJavaHome(File runtimeJavaHome) {
+        public void setRuntimeJavaHome(Provider<File> runtimeJavaHome) {
-            try {
+            BuildParams.runtimeJavaHome = runtimeJavaHome.map(javaHome -> {
-                BuildParams.runtimeJavaHome = requireNonNull(runtimeJavaHome).getCanonicalFile();
+                try {
-            } catch (IOException e) {
+                    return javaHome.getCanonicalFile();
-                throw new RuntimeException(e);
+                } catch (IOException e) {
-            }
+                    throw new RuntimeException(e);
+                }
+            });
         }
 
-        public void setIsRuntimeJavaHomeSet(boolean isRutimeJavaHomeSet) {
+        public void setIsRuntimeJavaHomeSet(boolean isRuntimeJavaHomeSet) {
-            BuildParams.isRuntimeJavaHomeSet = isRutimeJavaHomeSet;
+            BuildParams.isRuntimeJavaHomeSet = isRuntimeJavaHomeSet;
         }
 
         public void setJavaVersions(List<JavaHome> javaVersions) {
@@ -210,11 +212,11 @@ public class BuildParams {
             BuildParams.gradleJavaVersion = requireNonNull(gradleJavaVersion);
         }
 
-        public void setRuntimeJavaVersion(JavaVersion runtimeJavaVersion) {
+        public void setRuntimeJavaVersion(Provider<JavaVersion> runtimeJavaVersion) {
             BuildParams.runtimeJavaVersion = requireNonNull(runtimeJavaVersion);
         }
 
-        public void setRuntimeJavaDetails(String runtimeJavaDetails) {
+        public void setRuntimeJavaDetails(Provider<String> runtimeJavaDetails) {
             BuildParams.runtimeJavaDetails = runtimeJavaDetails;
         }
 

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/info/GlobalBuildInfoPlugin.java

@@ -8,6 +8,7 @@
 package org.elasticsearch.gradle.internal.info;
 
 import org.apache.commons.io.IOUtils;
+import org.elasticsearch.gradle.VersionProperties;
 import org.elasticsearch.gradle.internal.BwcVersions;
 import org.elasticsearch.gradle.internal.conventions.info.GitInfo;
 import org.elasticsearch.gradle.internal.conventions.info.ParallelDetector;
@@ -31,7 +32,6 @@ import org.gradle.internal.jvm.inspection.JvmInstallationMetadata;
 import org.gradle.internal.jvm.inspection.JvmMetadataDetector;
 import org.gradle.internal.jvm.inspection.JvmVendor;
 import org.gradle.jvm.toolchain.JavaLanguageVersion;
-import org.gradle.jvm.toolchain.JavaLauncher;
 import org.gradle.jvm.toolchain.JavaToolchainService;
 import org.gradle.jvm.toolchain.JavaToolchainSpec;
 import org.gradle.jvm.toolchain.JvmVendorSpec;
@@ -50,7 +50,6 @@ import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Locale;
-import java.util.Optional;
 import java.util.Random;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
@@ -97,9 +96,11 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
         JavaVersion minimumCompilerVersion = JavaVersion.toVersion(getResourceContents("/minimumCompilerVersion"));
         JavaVersion minimumRuntimeVersion = JavaVersion.toVersion(getResourceContents("/minimumRuntimeVersion"));
 
-        Optional<File> selectedRuntimeJavaHome = findRuntimeJavaHome();
+        Provider<File> explicitRuntimeJavaHome = findRuntimeJavaHome();
-        File actualRuntimeJavaHome = selectedRuntimeJavaHome.orElse(Jvm.current().getJavaHome());
+        boolean isExplicitRuntimeJavaHomeSet = explicitRuntimeJavaHome.isPresent();
-        boolean isRuntimeJavaHomeSet = selectedRuntimeJavaHome.isPresent();
+        Provider<File> actualRuntimeJavaHome = isExplicitRuntimeJavaHomeSet
+            ? explicitRuntimeJavaHome
+            : resolveJavaHomeFromToolChainService(VersionProperties.getBundledJdkMajorVersion());
 
         GitInfo gitInfo = GitInfo.gitInfo(project.getRootDir());
 
@@ -107,16 +108,22 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
             params.reset();
             params.setRuntimeJavaHome(actualRuntimeJavaHome);
             params.setJavaToolChainSpec(resolveToolchainSpecFromEnv());
+            Provider<JvmInstallationMetadata> runtimeJdkMetaData = actualRuntimeJavaHome.map(
+                runtimeJavaHome -> metadataDetector.getMetadata(getJavaInstallation(runtimeJavaHome))
+            );
             params.setRuntimeJavaVersion(
-                determineJavaVersion(
+                actualRuntimeJavaHome.map(
-                    "runtime java.home",
+                    javaHome -> determineJavaVersion(
-                    actualRuntimeJavaHome,
+                        "runtime java.home",
-                    isRuntimeJavaHomeSet ? minimumRuntimeVersion : Jvm.current().getJavaVersion()
+                        javaHome,
+                        isExplicitRuntimeJavaHomeSet
+                            ? minimumRuntimeVersion
+                            : JavaVersion.toVersion(VersionProperties.getBundledJdkMajorVersion())
+                    )
                 )
             );
-            params.setIsRuntimeJavaHomeSet(isRuntimeJavaHomeSet);
+            params.setIsRuntimeJavaHomeSet(isExplicitRuntimeJavaHomeSet);
-            JvmInstallationMetadata runtimeJdkMetaData = metadataDetector.getMetadata(getJavaInstallation(actualRuntimeJavaHome));
+            params.setRuntimeJavaDetails(runtimeJdkMetaData.map(m -> formatJavaVendorDetails(m)));
-            params.setRuntimeJavaDetails(formatJavaVendorDetails(runtimeJdkMetaData));
             params.setJavaVersions(getAvailableJavaVersions());
             params.setMinimumCompilerVersion(minimumCompilerVersion);
             params.setMinimumRuntimeVersion(minimumRuntimeVersion);
@@ -299,28 +306,30 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
         }
     }
 
-    private Optional<File> findRuntimeJavaHome() {
+    private Provider<File> findRuntimeJavaHome() {
         String runtimeJavaProperty = System.getProperty("runtime.java");
 
         if (runtimeJavaProperty != null) {
-            return Optional.of(resolveJavaHomeFromToolChainService(runtimeJavaProperty));
+            return resolveJavaHomeFromToolChainService(runtimeJavaProperty);
         }
-        String env = System.getenv("RUNTIME_JAVA_HOME");
+        if (System.getenv("RUNTIME_JAVA_HOME") != null) {
-        if (env != null) {
+            return providers.provider(() -> new File(System.getenv("RUNTIME_JAVA_HOME")));
-            return Optional.of(new File(env));
         }
         // fall back to tool chain if set.
-        env = System.getenv("JAVA_TOOLCHAIN_HOME");
+        String env = System.getenv("JAVA_TOOLCHAIN_HOME");
-        return env == null ? Optional.empty() : Optional.of(new File(env));
+        return providers.provider(() -> {
+            if (env == null) {
+                return null;
+            }
+            return new File(env);
+        });
     }
 
     @NotNull
-    private File resolveJavaHomeFromToolChainService(String version) {
+    private Provider<File> resolveJavaHomeFromToolChainService(String version) {
         Property<JavaLanguageVersion> value = objectFactory.property(JavaLanguageVersion.class).value(JavaLanguageVersion.of(version));
-        Provider<JavaLauncher> javaLauncherProvider = toolChainService.launcherFor(javaToolchainSpec -> {
+        return toolChainService.launcherFor(javaToolchainSpec -> javaToolchainSpec.getLanguageVersion().value(value))
-            javaToolchainSpec.getLanguageVersion().value(value);
+            .map(launcher -> launcher.getMetadata().getInstallationPath().getAsFile());
-        });
-        return javaLauncherProvider.get().getMetadata().getInstallationPath().getAsFile();
     }
 
     public static String getResourceContents(String resourcePath) {

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/precommit/ThirdPartyAuditPrecommitPlugin.java

@@ -66,10 +66,8 @@ public class ThirdPartyAuditPrecommitPlugin extends PrecommitPlugin {
                     )
                 );
             t.dependsOn(resourcesTask);
-            if (BuildParams.getIsRuntimeJavaHomeSet()) {
-                t.getJavaHome().set(project.provider(BuildParams::getRuntimeJavaHome).map(File::getPath));
-            }
             t.getTargetCompatibility().set(project.provider(BuildParams::getRuntimeJavaVersion));
+            t.getJavaHome().set(project.provider(BuildParams::getRuntimeJavaHome).map(File::getPath));
             t.setSignatureFile(resourcesDir.resolve("forbidden/third-party-audit.txt").toFile());
             t.getJdkJarHellClasspath().from(jdkJarHellConfig);
             t.getForbiddenAPIsClasspath().from(project.getConfigurations().getByName("forbiddenApisCliJar").plus(compileOnly));

build-tools/src/testFixtures/groovy/org/elasticsearch/gradle/fixtures/AbstractGradleFuncTest.groovy

@@ -13,6 +13,7 @@ import org.elasticsearch.gradle.internal.test.BuildConfigurationAwareGradleRunne
 import org.elasticsearch.gradle.internal.test.InternalAwareGradleRunner
 import org.elasticsearch.gradle.internal.test.NormalizeOutputGradleRunner
 import org.elasticsearch.gradle.internal.test.TestResultExtension
+import org.gradle.internal.component.external.model.ComponentVariant
 import org.gradle.testkit.runner.BuildResult
 import org.gradle.testkit.runner.GradleRunner
 import org.junit.Rule
@@ -22,6 +23,7 @@ import spock.lang.TempDir
 
 import java.lang.management.ManagementFactory
 import java.nio.file.Files
+import java.io.File
 import java.nio.file.Path
 import java.util.jar.JarEntry
 import java.util.jar.JarOutputStream