You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by dw...@apache.org on 2021/08/25 08:05:21 UTC
[lucene] 06/12: Use JavaInfo instead of toolchains. Internal but
works and is free of toolchain's quirks.
This is an automated email from the ASF dual-hosted git repository.
dweiss pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/lucene.git
commit 2b0378cd4adef87d2148c0b19ac6fc84de3b3dea
Author: Dawid Weiss <da...@carrotsearch.com>
AuthorDate: Tue Aug 24 12:33:36 2021 +0200
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 | 105 +++++++++-----------------
lucene/misc/native/build.gradle | 6 +-
4 files changed, 52 insertions(+), 89 deletions(-)
diff --git a/gradle/documentation/render-javadoc.gradle b/gradle/documentation/render-javadoc.gradle
index f592b97..5710025 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<String> luceneDocUrl = project.objects.property(String)
+ final Property<String> luceneDocUrl = project.objects.property(String)
// default is to require full javadocs
@Input
@@ -305,10 +307,10 @@ class RenderJavadocTask extends DefaultTask {
@Optional
ListProperty<String> extraOpts = project.objects.listProperty(String)
- @Nullable
@Optional
@Input
- def executable
+ final Property<String> 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 806049f..bc6cbab 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 b6b603e..d12a39d 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.
-
-// 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 = {
+//
+// 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.
+
+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 a443c3d..664410e 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")]) {