From 35a24a3a056022c08cec46c2d6224e6b089d42b5 Mon Sep 17 00:00:00 2001 From: Brice Dutheil Date: Tue, 21 Oct 2025 16:15:53 +0200 Subject: [PATCH 1/7] chore: Drop org.gradle.java.installations.fromEnv toolchain restriction --- gradle.properties | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gradle.properties b/gradle.properties index de0623c7424..1fe4ab6c54e 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,10 +1,10 @@ org.gradle.parallel=true org.gradle.caching=true org.gradle.jvmargs=-XX:MaxMetaspaceSize=1g -org.gradle.java.installations.auto-detect=false +org.gradle.java.installations.auto-detect=true org.gradle.java.installations.auto-download=false # 8, 11, 17, 21 and 25 are needed to build -org.gradle.java.installations.fromEnv=JAVA_8_HOME,JAVA_11_HOME,JAVA_17_HOME,JAVA_21_HOME,JAVA_25_HOME +#org.gradle.java.installations.fromEnv=JAVA_8_HOME,JAVA_11_HOME,JAVA_17_HOME,JAVA_21_HOME,JAVA_25_HOME # Toggle on to get more details during IJ sync #org.gradle.logging.level=info From 470c6e7cb09afe5f3b49669c6aacee3a6b415797 Mon Sep 17 00:00:00 2001 From: Brice Dutheil Date: Thu, 13 Nov 2025 13:51:50 +0100 Subject: [PATCH 2/7] chore: Drop org.gradle.java.installations toolchain restriction for local env, but keep them in CI --- .gitlab-ci.yml | 3 +++ gradle.properties | 6 ++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 21a50d58db1..da8e1e6efb3 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -171,6 +171,9 @@ default: - export ORG_GRADLE_PROJECT_akkaRepositoryToken=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-java.akka_repo_token --with-decryption --query "Parameter.Value" --out text) - export ORG_GRADLE_PROJECT_mavenRepositoryProxy=$MAVEN_REPOSITORY_PROXY - export ORG_GRADLE_PROJECT_gradlePluginProxy=$GRADLE_PLUGIN_PROXY + - export ORG_GRADLE_PROJECT_org.gradle.java.installations.auto-detect=false + - export ORG_GRADLE_PROJECT_org.gradle.java.installations.auto-download=false + - export ORG_GRADLE_PROJECT_org.gradle.java.installations.fromEnv=JAVA_8_HOME,JAVA_11_HOME,JAVA_17_HOME,JAVA_21_HOME,JAVA_25_HOME - mkdir -p .gradle - export GRADLE_USER_HOME=$(pwd)/.gradle # replace maven central part by MAVEN_REPOSITORY_PROXY in .mvn/wrapper/maven-wrapper.properties diff --git a/gradle.properties b/gradle.properties index 1fe4ab6c54e..b652b958d98 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,10 +1,8 @@ org.gradle.parallel=true org.gradle.caching=true org.gradle.jvmargs=-XX:MaxMetaspaceSize=1g -org.gradle.java.installations.auto-detect=true -org.gradle.java.installations.auto-download=false -# 8, 11, 17, 21 and 25 are needed to build -#org.gradle.java.installations.fromEnv=JAVA_8_HOME,JAVA_11_HOME,JAVA_17_HOME,JAVA_21_HOME,JAVA_25_HOME + +# CI use constrained org.gradle.java.installations settings # Toggle on to get more details during IJ sync #org.gradle.logging.level=info From c889363936949aa0f724a19883ee933fe20b4999 Mon Sep 17 00:00:00 2001 From: Brice Dutheil Date: Thu, 13 Nov 2025 14:46:47 +0100 Subject: [PATCH 3/7] chore: Drop org.gradle.java.installations toolchain restriction for local env, but keep them in CI --- .gitlab-ci.yml | 9 ++++++--- gradle.properties | 4 ++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index da8e1e6efb3..99bdec26cff 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -171,9 +171,12 @@ default: - export ORG_GRADLE_PROJECT_akkaRepositoryToken=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-java.akka_repo_token --with-decryption --query "Parameter.Value" --out text) - export ORG_GRADLE_PROJECT_mavenRepositoryProxy=$MAVEN_REPOSITORY_PROXY - export ORG_GRADLE_PROJECT_gradlePluginProxy=$GRADLE_PLUGIN_PROXY - - export ORG_GRADLE_PROJECT_org.gradle.java.installations.auto-detect=false - - export ORG_GRADLE_PROJECT_org.gradle.java.installations.auto-download=false - - export ORG_GRADLE_PROJECT_org.gradle.java.installations.fromEnv=JAVA_8_HOME,JAVA_11_HOME,JAVA_17_HOME,JAVA_21_HOME,JAVA_25_HOME + - | + cat >> gradle.properties <<'EOF' + org.gradle.java.installations.auto-detect=false + org.gradle.java.installations.auto-download=false + org.gradle.java.installations.fromEnv=JAVA_8_HOME,JAVA_11_HOME,JAVA_17_HOME,JAVA_21_HOME,JAVA_25_HOME + EOF - mkdir -p .gradle - export GRADLE_USER_HOME=$(pwd)/.gradle # replace maven central part by MAVEN_REPOSITORY_PROXY in .mvn/wrapper/maven-wrapper.properties diff --git a/gradle.properties b/gradle.properties index b652b958d98..48d5ceb5b49 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,7 +2,7 @@ org.gradle.parallel=true org.gradle.caching=true org.gradle.jvmargs=-XX:MaxMetaspaceSize=1g -# CI use constrained org.gradle.java.installations settings - # Toggle on to get more details during IJ sync #org.gradle.logging.level=info + +# CI use constrained org.gradle.java.installations settings From 1104f194d61de79214e22aadf89eeb51391f4b74 Mon Sep 17 00:00:00 2001 From: Brice Dutheil Date: Fri, 14 Nov 2025 11:47:25 +0100 Subject: [PATCH 4/7] feat: Allow discovery of testJvm without environment variables --- .../plugin/testJvmConstraints/TestJvmSpec.kt | 132 ++++++++++++++---- settings.gradle.kts | 1 + 2 files changed, 106 insertions(+), 27 deletions(-) diff --git a/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt b/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt index d78e96e68f0..99b40eae114 100644 --- a/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt +++ b/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt @@ -1,10 +1,18 @@ package datadog.gradle.plugin.testJvmConstraints -import org.gradle.kotlin.dsl.support.serviceOf import org.gradle.api.GradleException import org.gradle.api.Project +import org.gradle.api.internal.provider.PropertyFactory +import org.gradle.api.provider.Provider +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.JvmImplementation +import org.gradle.jvm.toolchain.JvmVendorSpec +import org.gradle.jvm.toolchain.internal.DefaultToolchainSpec +import org.gradle.jvm.toolchain.internal.SpecificInstallationToolchainSpec +import org.gradle.kotlin.dsl.support.serviceOf import java.nio.file.Files import java.nio.file.Path import java.nio.file.Paths @@ -16,10 +24,16 @@ class TestJvmSpec(val project: Project) { } private val currentJavaHomePath = project.providers.systemProperty("java.home").map { it.normalizeToJDKJavaHome() } - - val testJvmProperty = project.providers.gradleProperty(TEST_JVM) - val normalizedTestJvm = testJvmProperty.map { testJvm -> + /** + * The raw `testJvm` property as passed via command line or environment variable. + */ + val testJvmProperty: Provider = project.providers.gradleProperty(TEST_JVM) + + /** + * Normalized `stable` string to the highest JAVA_X_HOME found in environment variables. + */ + val normalizedTestJvm: Provider = testJvmProperty.map { testJvm -> if (testJvm.isBlank()) { throw GradleException("testJvm property is blank") } @@ -42,38 +56,92 @@ class TestJvmSpec(val project: Project) { } }.map { project.logger.info("normalized testJvm: $it"); it } - val testJvmHomePath = normalizedTestJvm.map { - if (Files.exists(Paths.get(it))) { - it.normalizeToJDKJavaHome() - } else { - val matcher = Regex("([a-zA-Z]*)([0-9]+)").find(it) - if (matcher == null) { - throw GradleException("Unable to find launcher for Java '$it'. It needs to match '([a-zA-Z]*)([0-9]+)'.") + /** + * The home path of the test JVM. + * + * The `` string (`8`, `11`, `ZULU8`, `GRAALVM25`, etc.) is interpreted in that order: + * 1. Lookup for a valid path, + * 2. Look for an environment variable named `JAVA__HOME` + * (e.g. `JAVA_8_HOME`, `JAVA_11_HOME`, etc. but also `JAVA_ZULU8_HOME`, `JAVA_GRAALVM25_HOME`, etc.) + * 3. Look for an environment variable named `` + * 4. Look JVM via Gradle toolchains + * + * Known forms + */ + private val testJvmSpec = normalizedTestJvm.map { + // https://github.com/DataDog/dd-trace-java-docker-build/blob/a4f4bfa9d7fe0708858e595697dc67970a2a458f/Dockerfile#L182-L188 + // https://github.com/DataDog/dd-trace-java-docker-build/blob/a4f4bfa9d7fe0708858e595697dc67970a2a458f/Dockerfile#L222-L241 + val testJvmSpec = when { + Files.exists(Paths.get(it)) -> it.logSource("existing path") + Regex("([a-zA-Z]*)([0-9]+)").find(it) != null -> + project.providers.environmentVariable("JAVA_${it}_HOME").orNull + ?.logSource("env var JAVA_${it}_HOME") + + project.providers.environmentVariable(it).isPresent -> + project.providers.environmentVariable(it).orNull + ?.logSource("env var $it") + else -> null + }?.normalizeToJDKJavaHome()?.toToolchainSpec() ?: run { + // Best effort to make a spec for the passed testJvm + // `8`, `11`, `ZULU8`, `GRAALVM25`, etc. + // if it is an integer, we assume it's a Java version + // also we can handle on macOs oracle, zulu, semeru, graalvm prefixes + + val (distribution, version) = Regex("([a-zA-Z]*)([0-9]+)").matchEntire(it)?.groupValues?.drop(1) ?: listOf("", "") + version.ifBlank { + return@run null } - val testJvmEnv = "JAVA_${it}_HOME" - val testJvmHome = project.providers.environmentVariable(testJvmEnv).orNull - if (testJvmHome == null) { - throw GradleException("Unable to find launcher for Java '$it'. Have you set '$testJvmEnv'?") + + // This is using internal APIs + DefaultToolchainSpec(project.serviceOf()).apply { + languageVersion.set(JavaLanguageVersion.of(version.toInt())) + when (distribution.lowercase()) { + "oracle" -> { + vendor.set(JvmVendorSpec.ORACLE) + } + "zulu" -> { + vendor.set(JvmVendorSpec.AZUL) + } + "semeru" -> { + vendor.set(JvmVendorSpec.IBM) + implementation.set(JvmImplementation.J9) + } + "graalvm" -> { + vendor.set(JvmVendorSpec.GRAAL_VM) + nativeImageCapable.set(true) + } + } } + } - testJvmHome.normalizeToJDKJavaHome() + if (testJvmSpec == null) { + throw GradleException( + """ + Unable to find launcher for Java '$it'. It needs to be: + 1. A valid path to a JDK home, or + 2. An environment variable named 'JAVA__HOME' or '' pointing to a JDK home, or + 3. A Java version or a known distribution+version combination (e.g. '11', 'zulu8', 'graalvm11', etc.) that can be resolved via Gradle toolchains. + 4. If using Gradle toolchains, ensure that the requested JDK is installed and configured correctly. + """.trimIndent()) } + + // The test JVM spec for the toolchain service + testJvmSpec }.map { project.logger.info("testJvm home path: $it"); it } - val javaTestLauncher = project.providers.zip(testJvmHomePath, normalizedTestJvm) { testJvmHome, testJvm -> + /** + * The Java launcher for the test JVM. + * + * Current JVM or a launcher specified via the testJvm. + */ + val javaTestLauncher: Provider = project.providers.zip(testJvmSpec, normalizedTestJvm) { jvmSpec, testJvm -> // Only change test JVM if it's not the one we are running the gradle build with - if (currentJavaHomePath.get() == testJvmHome) { + if ((jvmSpec as? SpecificInstallationToolchainSpec)?.javaHome == currentJavaHomePath.get()) { project.providers.provider { null } } else { - // This is using internal APIs - val jvmSpec = org.gradle.jvm.toolchain.internal.SpecificInstallationToolchainSpec( - project.serviceOf(), - project.file(testJvmHome) - ) - // The provider always says that a value is present so we need to wrap it for proper error messages project.javaToolchains.launcherFor(jvmSpec).orElse(project.providers.provider { - throw GradleException("Unable to find launcher for Java $testJvm. Does '$testJvmHome' point to a JDK?") + throw GradleException("Unable to find launcher for Java '$testJvm'. Does $TEST_JVM point to a JDK?") }) } }.flatMap { it }.map { project.logger.info("testJvm launcher: ${it.executablePath}"); it } @@ -83,6 +151,16 @@ class TestJvmSpec(val project: Project) { return if (javaHome.endsWith("jre")) javaHome.parent else javaHome } - private val Project.javaToolchains: JavaToolchainService get() = - extensions.getByName("javaToolchains") as JavaToolchainService + private fun String.logSource(resolutionMode: String): String { + project.logger.info("$TEST_JVM=$this resolved from $resolutionMode") + return this + } + + private fun Path.toToolchainSpec() : JavaToolchainSpec = + // This is using internal APIs + SpecificInstallationToolchainSpec(project.serviceOf(), project.file(this)) + + private val Project.javaToolchains: JavaToolchainService + get() = + extensions.getByName("javaToolchains") as JavaToolchainService } diff --git a/settings.gradle.kts b/settings.gradle.kts index 92aba9c108e..58d140e1cc7 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -21,6 +21,7 @@ pluginManagement { plugins { id("com.gradle.develocity") version "4.2.2" + id("org.gradle.toolchains.foojay-resolver-convention") version "0.10.0" } val isCI = providers.environmentVariable("CI") From a69026862185749eb61ee20e38ea105a0f11a1bc Mon Sep 17 00:00:00 2001 From: Brice Dutheil Date: Fri, 14 Nov 2025 11:59:22 +0100 Subject: [PATCH 5/7] feat: Only rely on Gradle's toolchain to run tests --- .../plugin/testJvmConstraints/TestJvmSpec.kt | 160 +++++++++--------- 1 file changed, 78 insertions(+), 82 deletions(-) diff --git a/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt b/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt index 99b40eae114..a8e108ad282 100644 --- a/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt +++ b/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt @@ -17,7 +17,20 @@ import java.nio.file.Files import java.nio.file.Path import java.nio.file.Paths - +/** + * Handles the `testJvm` property to resolve a Java launcher for testing. + * + * The `testJvm` property can be set via command line or environment variable to specify + * which JVM to use for running tests. E.g. + * + * ```shell + * ./gradlew test -DtestJvm=ZULU11 + * ``` + * + * This handles local setup, and CI environment, where the environment variables are defined here: + * * https://github.com/DataDog/dd-trace-java-docker-build/blob/a4f4bfa9d7fe0708858e595697dc67970a2a458f/Dockerfile#L182-L188 + * * https://github.com/DataDog/dd-trace-java-docker-build/blob/a4f4bfa9d7fe0708858e595697dc67970a2a458f/Dockerfile#L222-L241 + */ class TestJvmSpec(val project: Project) { companion object { const val TEST_JVM = "testJvm" @@ -39,20 +52,22 @@ class TestJvmSpec(val project: Project) { } // "stable" is calculated as the largest X found in JAVA_X_HOME - if (testJvm == "stable") { - val javaVersions = project.providers.environmentVariablesPrefixedBy("JAVA_").map { javaHomes -> - javaHomes - .filter { it.key.matches(Regex("^JAVA_[0-9]+_HOME$")) } - .map { Regex("^JAVA_(\\d+)_HOME$").find(it.key)!!.groupValues[1].toInt() } - }.get() - - if (javaVersions.isEmpty()) { - throw GradleException("No valid JAVA_X_HOME environment variables found.") + when (testJvm) { + "stable" -> { + val javaVersions = project.providers.environmentVariablesPrefixedBy("JAVA_").map { javaHomes -> + javaHomes + .filter { it.key.matches(Regex("^JAVA_[0-9]+_HOME$")) } + .map { Regex("^JAVA_(\\d+)_HOME$").find(it.key)!!.groupValues[1].toInt() } + }.get() + + if (javaVersions.isEmpty()) { + throw GradleException("No valid JAVA_X_HOME environment variables found.") + } + + javaVersions.max().toString() } - javaVersions.max().toString() - } else { - testJvm + else -> testJvm } }.map { project.logger.info("normalized testJvm: $it"); it } @@ -61,72 +76,57 @@ class TestJvmSpec(val project: Project) { * * The `` string (`8`, `11`, `ZULU8`, `GRAALVM25`, etc.) is interpreted in that order: * 1. Lookup for a valid path, - * 2. Look for an environment variable named `JAVA__HOME` - * (e.g. `JAVA_8_HOME`, `JAVA_11_HOME`, etc. but also `JAVA_ZULU8_HOME`, `JAVA_GRAALVM25_HOME`, etc.) - * 3. Look for an environment variable named `` - * 4. Look JVM via Gradle toolchains + * 2. Look JVM via Gradle toolchains * - * Known forms + * Holds the resolved JavaToolchainSpec for the test JVM. */ private val testJvmSpec = normalizedTestJvm.map { - // https://github.com/DataDog/dd-trace-java-docker-build/blob/a4f4bfa9d7fe0708858e595697dc67970a2a458f/Dockerfile#L182-L188 - // https://github.com/DataDog/dd-trace-java-docker-build/blob/a4f4bfa9d7fe0708858e595697dc67970a2a458f/Dockerfile#L222-L241 - val testJvmSpec = when { - Files.exists(Paths.get(it)) -> it.logSource("existing path") - Regex("([a-zA-Z]*)([0-9]+)").find(it) != null -> - project.providers.environmentVariable("JAVA_${it}_HOME").orNull - ?.logSource("env var JAVA_${it}_HOME") - - project.providers.environmentVariable(it).isPresent -> - project.providers.environmentVariable(it).orNull - ?.logSource("env var $it") - else -> null - }?.normalizeToJDKJavaHome()?.toToolchainSpec() ?: run { - // Best effort to make a spec for the passed testJvm - // `8`, `11`, `ZULU8`, `GRAALVM25`, etc. - // if it is an integer, we assume it's a Java version - // also we can handle on macOs oracle, zulu, semeru, graalvm prefixes - - val (distribution, version) = Regex("([a-zA-Z]*)([0-9]+)").matchEntire(it)?.groupValues?.drop(1) ?: listOf("", "") - version.ifBlank { - return@run null - } - - // This is using internal APIs - DefaultToolchainSpec(project.serviceOf()).apply { - languageVersion.set(JavaLanguageVersion.of(version.toInt())) - when (distribution.lowercase()) { - "oracle" -> { - vendor.set(JvmVendorSpec.ORACLE) - } - "zulu" -> { - vendor.set(JvmVendorSpec.AZUL) - } - "semeru" -> { - vendor.set(JvmVendorSpec.IBM) - implementation.set(JvmImplementation.J9) - } - "graalvm" -> { - vendor.set(JvmVendorSpec.GRAAL_VM) - nativeImageCapable.set(true) + val (distribution, version) = Regex("([a-zA-Z]*)([0-9]+)").matchEntire(it)?.groupValues?.drop(1) ?: listOf("", "") + + when { + Files.exists(Paths.get(it)) -> it.normalizeToJDKJavaHome().toToolchainSpec() + + version.isNotBlank() -> { + // Best effort to make a spec for the passed testJvm + // `8`, `11`, `ZULU8`, `GRAALVM25`, etc. + // if it is an integer, we assume it's a Java version + // also we can handle on macOs oracle, zulu, semeru, graalvm prefixes + + // This is using internal APIs + DefaultToolchainSpec(project.serviceOf()).apply { + languageVersion.set(JavaLanguageVersion.of(version.toInt())) + when (distribution.lowercase()) { + "oracle" -> { + vendor.set(JvmVendorSpec.ORACLE) + } + + "zulu" -> { + vendor.set(JvmVendorSpec.AZUL) + } + + "semeru" -> { + vendor.set(JvmVendorSpec.IBM) + implementation.set(JvmImplementation.J9) + } + + "graalvm" -> { + vendor.set(JvmVendorSpec.GRAAL_VM) + nativeImageCapable.set(true) + } } } } - } - if (testJvmSpec == null) { - throw GradleException( + else -> throw GradleException( """ Unable to find launcher for Java '$it'. It needs to be: 1. A valid path to a JDK home, or 2. An environment variable named 'JAVA__HOME' or '' pointing to a JDK home, or 3. A Java version or a known distribution+version combination (e.g. '11', 'zulu8', 'graalvm11', etc.) that can be resolved via Gradle toolchains. 4. If using Gradle toolchains, ensure that the requested JDK is installed and configured correctly. - """.trimIndent()) + """.trimIndent() + ) } - - // The test JVM spec for the toolchain service - testJvmSpec }.map { project.logger.info("testJvm home path: $it"); it } /** @@ -134,29 +134,25 @@ class TestJvmSpec(val project: Project) { * * Current JVM or a launcher specified via the testJvm. */ - val javaTestLauncher: Provider = project.providers.zip(testJvmSpec, normalizedTestJvm) { jvmSpec, testJvm -> - // Only change test JVM if it's not the one we are running the gradle build with - if ((jvmSpec as? SpecificInstallationToolchainSpec)?.javaHome == currentJavaHomePath.get()) { - project.providers.provider { null } - } else { - // The provider always says that a value is present so we need to wrap it for proper error messages - project.javaToolchains.launcherFor(jvmSpec).orElse(project.providers.provider { - throw GradleException("Unable to find launcher for Java '$testJvm'. Does $TEST_JVM point to a JDK?") - }) - } - }.flatMap { it }.map { project.logger.info("testJvm launcher: ${it.executablePath}"); it } + val javaTestLauncher: Provider = + project.providers.zip(testJvmSpec, normalizedTestJvm) { jvmSpec, testJvm -> + // Only change test JVM if it's not the one we are running the gradle build with + if ((jvmSpec as? SpecificInstallationToolchainSpec)?.javaHome == currentJavaHomePath.get()) { + project.providers.provider { null } + } else { + // The provider always says that a value is present so we need to wrap it for proper error messages + project.javaToolchains.launcherFor(jvmSpec).orElse(project.providers.provider { + throw GradleException("Unable to find launcher for Java '$testJvm'. Does $TEST_JVM point to a JDK?") + }) + } + }.flatMap { it }.map { project.logger.info("testJvm launcher: ${it.executablePath}"); it } private fun String.normalizeToJDKJavaHome(): Path { val javaHome = project.file(this).toPath().toRealPath() return if (javaHome.endsWith("jre")) javaHome.parent else javaHome } - private fun String.logSource(resolutionMode: String): String { - project.logger.info("$TEST_JVM=$this resolved from $resolutionMode") - return this - } - - private fun Path.toToolchainSpec() : JavaToolchainSpec = + private fun Path.toToolchainSpec(): JavaToolchainSpec = // This is using internal APIs SpecificInstallationToolchainSpec(project.serviceOf(), project.file(this)) From 501af3d4574bf20ac63dfb6d3e0d2f5367349dd6 Mon Sep 17 00:00:00 2001 From: Brice Dutheil Date: Fri, 14 Nov 2025 12:39:54 +0100 Subject: [PATCH 6/7] fix: Auto discover JAVA_xx_HOME variables from the build image --- .gitlab-ci.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 99bdec26cff..3c7310d283e 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -172,10 +172,11 @@ default: - export ORG_GRADLE_PROJECT_mavenRepositoryProxy=$MAVEN_REPOSITORY_PROXY - export ORG_GRADLE_PROJECT_gradlePluginProxy=$GRADLE_PLUGIN_PROXY - | - cat >> gradle.properties <<'EOF' + JAVA_HOMES=$(env | grep -E '^JAVA_[A-Z0-9_]+_HOME=' | sed 's/=.*//' | paste -sd,) + cat >> gradle.properties < Date: Thu, 20 Nov 2025 17:59:36 +0100 Subject: [PATCH 7/7] typo: Use `-P` Co-authored-by: Sarah Chen --- .../datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt b/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt index a8e108ad282..f0e044ac958 100644 --- a/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt +++ b/buildSrc/src/main/kotlin/datadog/gradle/plugin/testJvmConstraints/TestJvmSpec.kt @@ -24,7 +24,7 @@ import java.nio.file.Paths * which JVM to use for running tests. E.g. * * ```shell - * ./gradlew test -DtestJvm=ZULU11 + * ./gradlew test -PtestJvm=ZULU11 * ``` * * This handles local setup, and CI environment, where the environment variables are defined here: