From 2b0378cd4adef87d2148c0b19ac6fc84de3b3dea Mon Sep 17 00:00:00 2001 From: Dawid Weiss Date: Tue, 24 Aug 2021 12:33:36 +0200 Subject: [PATCH] Use JavaInfo instead of toolchains. Internal but works and is free of toolchain's quirks. --- gradle/documentation/render-javadoc.gradle | 21 ++-- gradle/generation/local-settings.gradle | 9 +- gradle/testing/alternative-jdk-support.gradle | 103 ++++++------------ lucene/misc/native/build.gradle | 6 +- 4 files changed, 51 insertions(+), 88 deletions(-) diff --git a/gradle/documentation/render-javadoc.gradle b/gradle/documentation/render-javadoc.gradle index f592b97edf1..571002562a6 100644 --- a/gradle/documentation/render-javadoc.gradle +++ b/gradle/documentation/render-javadoc.gradle @@ -1,3 +1,5 @@ +import org.gradle.internal.jvm.Jvm + import javax.annotation.Nullable /* @@ -287,7 +289,7 @@ class RenderJavadocTask extends DefaultTask { @Input @Optional - Property luceneDocUrl = project.objects.property(String) + final Property luceneDocUrl = project.objects.property(String) // default is to require full javadocs @Input @@ -305,10 +307,10 @@ class RenderJavadocTask extends DefaultTask { @Optional ListProperty extraOpts = project.objects.listProperty(String) - @Nullable @Optional @Input - def executable + final Property executable = project.objects.property(String).convention( + project.provider { Jvm.current().javadocExecutable.toString() }) @Input def taskResources @@ -443,17 +445,8 @@ class RenderJavadocTask extends DefaultTask { } }) - def javadocCmd = { - if (executable == null) { - //JavaInstallationRegistry registry = project.extensions.getByType(JavaInstallationRegistry) - //JavaInstallation currentJvm = registry.installationForCurrentVirtualMachine.get() - return currentJvm.jdk.get().javadocExecutable.asFile - } else { - return project.file(executable) - } - }() - - logger.info("Javadoc executable used: ${javadocCmd}") + def javadocCmd = project.file(executable.get()) + logger.lifecycle("Javadoc executable used: ${javadocCmd}") project.quietExec { executable javadocCmd diff --git a/gradle/generation/local-settings.gradle b/gradle/generation/local-settings.gradle index 806049f43f4..bc6cbab2503 100644 --- a/gradle/generation/local-settings.gradle +++ b/gradle/generation/local-settings.gradle @@ -53,7 +53,14 @@ configure(rootProject) { "org.gradle.workers.max=${maxWorkers}", "", "# Maximum number of test JVMs forked per test task.", - "tests.jvms=${testsJvms}" + "tests.jvms=${testsJvms}", + "", + "# Disable auto JVM provisioning", + "org.gradle.java.installations.auto-download=false", + "", + "# Set these to enable automatic JVM location discovery.", + "# org.gradle.java.installations.fromEnv=JDK11,JDK12,JDK13,JDK14,JDK15,JDK16,JDK17", + "# org.gradle.java.installations.paths=(custom paths)", ].join("\n"), "UTF-8") logger.log(LogLevel.WARN, "\nIMPORTANT. This is the first time you ran the build. " + diff --git a/gradle/testing/alternative-jdk-support.gradle b/gradle/testing/alternative-jdk-support.gradle index b6b603ef45c..d12a39d96dc 100644 --- a/gradle/testing/alternative-jdk-support.gradle +++ b/gradle/testing/alternative-jdk-support.gradle @@ -1,7 +1,8 @@ + +import org.gradle.internal.jvm.JavaInfo import org.gradle.internal.jvm.Jvm +import org.gradle.internal.jvm.inspection.JvmInstallationMetadata import org.gradle.internal.jvm.inspection.JvmMetadataDetector -import org.gradle.jvm.toolchain.internal.JavaInstallationRegistry -import org.gradle.jvm.toolchain.internal.JavaToolchainQueryService /* * Licensed to the Apache Software Foundation (ASF) under one or more @@ -21,104 +22,68 @@ import org.gradle.jvm.toolchain.internal.JavaToolchainQueryService */ // This adds support for compiling and testing against a different Java runtime. -// This is the only way to build against JVMs not yet supported by Gradle itself. +// +// I failed to set it up leveraging Gradle's toolchains because +// a toolchain spec is not flexible enough to provide an exact location of the JVM to be used; +// if you have two identical JVM lang. versions in auto-discovered JVMs, an arbitrary one is used (?). +// This situation is not uncommon when debugging low-level stuff (hand-compiled JVM binaries). +// +// The code below is a workaround using internal gradle classes. It may stop working in the future +// but for now it's fine. -// Set up root project's property. -rootProject.ext.runtimeJava = null -rootProject.ext.runtimeJavaVersion = null - -def home = Jvm.current().javaHome -def otherHome = file("c:\\Tools\\java\\jdk13") -def spec = new org.gradle.jvm.toolchain.internal.SpecificInstallationToolchainSpec(objects, otherHome) - -JavaInstallationRegistry installationRegistry = project.services.get(JavaInstallationRegistry) -JvmMetadataDetector jvmDetector = project.services.get(JvmMetadataDetector) -JavaToolchainService toolchainService = project.extensions.getByType(JavaToolchainService) - -installationRegistry.listInstallations().each {inst -> - println "# " + inst.source + " " + inst.location - println " " + jvmDetector.getMetadata(inst.location).languageVersion -} - -JavaVersion runtimeVersion = Jvm.current().javaVersion - -configure(project(":lucene:core"), { - plugins.withType(JavaPlugin) { - java { - toolchain { - languageVersion = JavaLanguageVersion.of(11) - } - } - - task foo { - doFirst { - logger.lifecycle("runtime.version: " + runtimeVersion) - logger.lifecycle("toolchain: " + java.toolchain.displayName + " " + project.path) - logger.lifecycle("compiler: " + toolchainService.launcherFor(java.toolchain).get().executablePath) - logger.lifecycle("compiler2: " + - toolchainService.launcherFor(spec).get().executablePath) - } - } - } -}) - - -/* -JavaInstallationRegistry registry = extensions.getByType(JavaInstallationRegistry) - -JavaInstallation currentJvm = registry.installationForCurrentVirtualMachine.get() - -JavaInstallation altJvm = { +JavaInfo jvmGradle = Jvm.current(); +JavaInfo jvmCurrent = { def runtimeJavaHome = propertyOrDefault("runtime.java.home", System.getenv('RUNTIME_JAVA_HOME')) - if (!runtimeJavaHome) { - return currentJvm + if (runtimeJavaHome != null) { + return Jvm.forHome(file(runtimeJavaHome)) } else { - return registry.installationForDirectory( - layout.projectDirectory.dir(runtimeJavaHome)).get() + return jvmGradle } }() -// Set up root project's property. -rootProject.ext.runtimeJava = altJvm -rootProject.ext.runtimeJavaVersion = altJvm.javaVersion - -if (!currentJvm.javaExecutable.equals(altJvm.javaExecutable)) { - // Set up java toolchain tasks to use the alternative Java. - // This is a related Gradle issue for the future: - // https://github.com/gradle/gradle/issues/1652 +JvmMetadataDetector jvmDetector = project.services.get(JvmMetadataDetector) +if (jvmGradle != jvmCurrent) { configure(rootProject) { task altJvmWarning() { doFirst { + + def jvmInfo = { JavaInfo javaInfo -> + JvmInstallationMetadata jvmMetadata = jvmDetector.getMetadata(javaInfo.javaHome) + return "${jvmMetadata.languageVersion} (${jvmMetadata.displayName} ${jvmMetadata.runtimeVersion}, home at: ${jvmMetadata.javaHome})" + } + logger.warn("""NOTE: Alternative java toolchain will be used for compilation and tests: - Project will use Java ${altJvm.javaVersion} from: ${altJvm.installationDirectory} - Gradle runs with Java ${currentJvm.javaVersion} from: ${currentJvm.installationDirectory} + Project will use ${jvmInfo(jvmCurrent)} + Gradle runs with ${jvmInfo(jvmGradle)} """) } } } - // Set up toolchain-dependent tasks to use the alternative JVM. allprojects { // Any tests tasks.withType(Test) { dependsOn ":altJvmWarning" - executable = altJvm.javaExecutable + executable = jvmCurrent.javaExecutable } // Any javac compilation tasks tasks.withType(JavaCompile) { dependsOn ":altJvmWarning" options.fork = true - options.forkOptions.javaHome = altJvm.installationDirectory.asFile + options.forkOptions.javaHome = jvmCurrent.javaHome } // Javadoc compilation. - def javadocExecutable = altJvm.jdk.get().javadocExecutable.asFile + def javadocExecutable = jvmCurrent.javadocExecutable tasks.matching { it.name == "renderJavadoc" || it.name == "renderSiteJavadoc" }.all { dependsOn ":altJvmWarning" - executable = javadocExecutable + executable = javadocExecutable.toString() } } } -*/ \ No newline at end of file + +// Set up root project's properties. +rootProject.ext.runtimeJavaHome = jvmCurrent.javaHome +rootProject.ext.runtimeJavaVersion = jvmDetector.getMetadata(jvmCurrent.javaHome).languageVersion diff --git a/lucene/misc/native/build.gradle b/lucene/misc/native/build.gradle index a443c3d47d4..664410ed903 100644 --- a/lucene/misc/native/build.gradle +++ b/lucene/misc/native/build.gradle @@ -41,11 +41,9 @@ library { } tasks.withType(CppCompile).configureEach { - // TODO: this should use the default java toolchain, not runtime's - def javaHome = null // rootProject.ext.runtimeJava.getInstallationDirectory().getAsFile().getPath() + def javaHome = rootProject.ext.runtimeJavaHome - // Assume standard openjdk layout. This means only one architecture-specific include folder - // is present. + // Assume standard openjdk layout. This means only one architecture-specific include folder is present. systemIncludes.from file("${javaHome}/include") for (def path : [file("${javaHome}/include/win32")]) {