From a16d9227cf291b64029abfa74536ea6663c4f009 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bjo=CC=88rn=20Antonsson?= Date: Tue, 1 Mar 2022 15:12:09 +0100 Subject: [PATCH] Restructure MultiJDK testing to override JDK instead of creating tasks --- .circleci/config.yml | 57 ++---- CONTRIBUTING.md | 12 +- communication/communication.gradle | 3 - .../agent-bootstrap/agent-bootstrap.gradle | 12 +- .../profiling-auxiliary-async.gradle | 16 +- .../profiling-controller-openjdk.gradle | 16 +- .../agent-tooling/agent-tooling.gradle | 17 +- .../weblog/weblog-common/weblog-common.gradle | 4 +- .../akka-http-10.0/akka-http-10.0.gradle | 9 +- .../exception-profiling.gradle | 23 +-- .../jax-rs-annotations-2.gradle | 12 +- .../instrumentation/jdbc/jdbc.gradle | 7 +- .../instrumentation/jetty-11/jetty-11.gradle | 24 +-- .../java9-modules/java9-modules.gradle | 71 ++----- .../moduleapp/ModuleApplication.java | 0 .../main/{java9 => java11}/module-info.java | 0 .../profiling-integration-tests.gradle | 6 +- dd-trace-core/jfr-openjdk/jfr-openjdk.gradle | 16 +- gradle.properties | 5 +- gradle/java_no_deps.gradle | 190 ++++++++---------- utils/test-agent-utils/decoder/decoder.gradle | 3 - 21 files changed, 196 insertions(+), 307 deletions(-) rename dd-smoke-tests/java9-modules/src/main/{java9 => java11}/datadog/smoketest/moduleapp/ModuleApplication.java (100%) rename dd-smoke-tests/java9-modules/src/main/{java9 => java11}/module-info.java (100%) diff --git a/.circleci/config.yml b/.circleci/config.yml index f579d0f295e..3516e723d4f 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -39,7 +39,7 @@ save_cache_paths: &save_cache_paths test_matrix: &test_matrix parameters: - testTask: [ "7", "IBM8", "ZULU8","ORACLE8", "11", "ZULU11", "ZULU13", "15" ] + testJvm: [ "7", "IBM8", "ZULU8","ORACLE8", "11", "ZULU11", "ZULU13", "15" ] parameters: gradle_flags: @@ -172,9 +172,10 @@ jobs: parameters: testTask: type: string - prefixTestTask: - default: false - type: boolean + default: "test" + testJvm: + type: string + default: "" steps: - setup_code @@ -187,7 +188,8 @@ jobs: command: >- MAVEN_OPTS="-Xms64M -Xmx512M" GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1940M -Xms512M -XX:ErrorFile=/tmp/hs_err_pid%p.log' -Ddatadog.forkedMaxHeapSize=512M -Ddatadog.forkedMinHeapSize=128M" - ./gradlew <<# parameters.prefixTestTask>>testJava<><< parameters.testTask >> -PskipInstTests -PskipSmokeTests + ./gradlew << parameters.testTask >> -PskipInstTests -PskipSmokeTests + <<# parameters.testJvm >>-PtestJvm=<< parameters.testJvm >><> << pipeline.parameters.gradle_flags >> --max-workers=8 --continue @@ -245,13 +247,6 @@ jobs: POSTGRES_PASSWORD: sa POSTGRES_DB: jdbcUnitTest - parameters: - testTask: - type: string - prefixTestTask: - default: false - type: boolean - steps: - setup_code @@ -263,7 +258,8 @@ jobs: command: >- MAVEN_OPTS="-Xms64M -Xmx512M" GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1940M -Xms512M -XX:ErrorFile=/tmp/hs_err_pid%p.log' -Ddatadog.forkedMaxHeapSize=512M -Ddatadog.forkedMinHeapSize=128M" - ./gradlew :dd-java-agent:instrumentation:<<# parameters.prefixTestTask>>testJava<><< parameters.testTask >> + ./gradlew :dd-java-agent:instrumentation:<< parameters.testTask >> + <<# parameters.testJvm >>-PtestJvm=<< parameters.testJvm >><> << pipeline.parameters.gradle_flags >> --max-workers=6 --continue @@ -304,13 +300,6 @@ jobs: # This is used by mongodb smoke tests - image: mongo - parameters: - testTask: - type: string - prefixTestTask: - default: false - type: boolean - steps: - setup_code @@ -322,7 +311,8 @@ jobs: command: >- MAVEN_OPTS="-Xms64M -Xmx512M" GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1750M -Xms512M -XX:ErrorFile=/tmp/hs_err_pid%p.log' -Ddatadog.forkedMaxHeapSize=512M -Ddatadog.forkedMinHeapSize=128M" - ./gradlew stageMainDist :dd-smoke-test:<<# parameters.prefixTestTask>>testJava<><< parameters.testTask >> + ./gradlew stageMainDist :dd-smoke-test:<< parameters.testTask >> + <<# parameters.testJvm >>-PtestJvm=<< parameters.testJvm >><> << pipeline.parameters.gradle_flags >> --max-workers=2 --continue @@ -362,12 +352,12 @@ jobs: - image: alpine parameters: - testTask: + testJvm: type: string steps: - run: - name: All tests for << parameters.testTask >> passed! + name: All tests for << parameters.testJvm >> passed! command: echo 'All tests passed!' agent_integration_tests: @@ -472,8 +462,7 @@ build_test_jobs: &build_test_jobs - base_tests: requires: - build - prefixTestTask: true - name: z_test_<< matrix.testTask >>_base + name: z_test_<< matrix.testJvm >>_base matrix: <<: *test_matrix @@ -486,8 +475,7 @@ build_test_jobs: &build_test_jobs - instrumentation_tests: requires: - build - prefixTestTask: true - name: z_test_<< matrix.testTask >>_inst + name: z_test_<< matrix.testJvm >>_inst matrix: <<: *test_matrix @@ -495,7 +483,6 @@ build_test_jobs: &build_test_jobs requires: - build name: z_test_8_inst - testTask: test - instrumentation_tests: requires: @@ -506,8 +493,7 @@ build_test_jobs: &build_test_jobs - smoke_tests: requires: - build - prefixTestTask: true - name: z_test_<< matrix.testTask >>_smoke + name: z_test_<< matrix.testJvm >>_smoke matrix: <<: *test_matrix @@ -515,14 +501,13 @@ build_test_jobs: &build_test_jobs requires: - build name: z_test_8_smoke - testTask: test - fan_in: requires: - - z_test_<< matrix.testTask >>_base - - z_test_<< matrix.testTask >>_inst - - z_test_<< matrix.testTask >>_smoke - name: test_<< matrix.testTask >> + - z_test_<< matrix.testJvm >>_base + - z_test_<< matrix.testJvm >>_inst + - z_test_<< matrix.testJvm >>_smoke + name: test_<< matrix.testJvm >> matrix: <<: *test_matrix @@ -532,7 +517,7 @@ build_test_jobs: &build_test_jobs - z_test_8_inst - z_test_8_smoke name: test_8 - testTask: "8" + testJvm: "8" - agent_integration_tests: requires: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 5daaea8a1cb..2462d1516fc 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -5,7 +5,7 @@ and discuss your ideas or propose the changes you wish to make. After a resoluti ## Requirements -To build the full project from the command line you need to have JDK versions for 7,8,11, and 14 installed on your machine, as well as the following environment variables set up: `JAVA_7_HOME, JAVA_8_HOME, JAVA_11_HOME, JAVA_14_HOME`, pointing to the respective JDK. +To build the full project from the command line you need to have JDK versions for 8 and 11 installed on your machine, as well as the following environment variables set up: `JAVA_8_HOME, JAVA_11_HOME`, pointing to the respective JDK. In contrast to the [IntelliJ IDEA setup](#intellij-idea) the default JVM to build and run tests from the command line should be Java 8. @@ -186,3 +186,13 @@ Suggested plugins and settings: * IntelliJ Gradle fails to import the project with `JAVA_11_HOME must be set to build Java 11 code` * A workaround is to run IntelliJ from terminal with `JAVA_11_HOME` * In order to verify what's visible from IntelliJ use `Add Configuration` bar and go to `Add New` -> `Gradle` -> `Environmental Variables` + +## Running tests on another JVM + +To run tests on a different JVM than the one used for doing the build, you need two things: + +1) An environment variable pointing to the JVM to use on the form `JAVA_[JDKNAME]_HOME`, i.e. `JAVA_ZULU15_HOME` + +2) A command line option to the gradle task on the form `-PtestJvm=[JDKNAME]`, i.e. `-PtestJvm=ZULU15` + +Please note that the JDK name needs to end with the JDK version, i.e. `11`, `ZULU15`, `ORACLE8`, et.c. diff --git a/communication/communication.gradle b/communication/communication.gradle index ded3cd110e8..f7f1acb7bf9 100644 --- a/communication/communication.gradle +++ b/communication/communication.gradle @@ -1,8 +1,5 @@ apply from: "$rootDir/gradle/java.gradle" -sourceCompatibility = JavaVersion.VERSION_1_7 -targetCompatibility = JavaVersion.VERSION_1_7 - dependencies { implementation deps.slf4j diff --git a/dd-java-agent/agent-bootstrap/agent-bootstrap.gradle b/dd-java-agent/agent-bootstrap/agent-bootstrap.gradle index ec6216c911b..23282aedefa 100644 --- a/dd-java-agent/agent-bootstrap/agent-bootstrap.gradle +++ b/dd-java-agent/agent-bootstrap/agent-bootstrap.gradle @@ -32,21 +32,21 @@ sourceSets { java.srcDirs "${project.projectDir}/src/main/java11" } } -compileMain_java11Java.doFirst { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build profiling helpers') - } - options.fork = true - options.forkOptions.javaHome = file(System.env.JAVA_11_HOME) + +compileMain_java11Java.configure { sourceCompatibility = JavaVersion.VERSION_1_8 targetCompatibility = JavaVersion.VERSION_1_8 + setJavaVersion(it, 11) } + dependencies { main_java11CompileOnly project(':internal-api:internal-api-8') } + jar { from sourceSets.main_java11.output } + idea { module { jdkName = '11' diff --git a/dd-java-agent/agent-profiling/profiling-auxiliary-async/profiling-auxiliary-async.gradle b/dd-java-agent/agent-profiling/profiling-auxiliary-async/profiling-auxiliary-async.gradle index 1851f91dd63..392b00ac906 100644 --- a/dd-java-agent/agent-profiling/profiling-auxiliary-async/profiling-auxiliary-async.gradle +++ b/dd-java-agent/agent-profiling/profiling-auxiliary-async/profiling-auxiliary-async.gradle @@ -62,17 +62,11 @@ configurations.all { [JavaCompile, GroovyCompile].each { tasks.withType(it).configureEach { - doFirst { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build profiling auxiliary') - } - // Disable '-processing' because some annotations are not claimed. - // Disable '-options' because we are compiling for java8 without specifying bootstrap - intentionally. - // Disable '-path' because we do not have some of the paths seem to be missing. - options.compilerArgs.addAll(['-Xlint:all,-processing,-options,-path'/*, '-Werror'*/]) - options.fork = true - options.forkOptions.javaHome = file(System.env.JAVA_11_HOME) - } + setJavaVersion(it, 11) + // Disable '-processing' because some annotations are not claimed. + // Disable '-options' because we are compiling for java8 without specifying bootstrap - intentionally. + // Disable '-path' because we do not have some of the paths seem to be missing. + options.compilerArgs.addAll(['-Xlint:all,-processing,-options,-path'/*, '-Werror'*/]) } } diff --git a/dd-java-agent/agent-profiling/profiling-controller-openjdk/profiling-controller-openjdk.gradle b/dd-java-agent/agent-profiling/profiling-controller-openjdk/profiling-controller-openjdk.gradle index 9d108be8f0d..5dbeef24fc3 100644 --- a/dd-java-agent/agent-profiling/profiling-controller-openjdk/profiling-controller-openjdk.gradle +++ b/dd-java-agent/agent-profiling/profiling-controller-openjdk/profiling-controller-openjdk.gradle @@ -37,17 +37,11 @@ targetCompatibility = JavaVersion.VERSION_1_8 [JavaCompile, GroovyCompile].each { tasks.withType(it).configureEach { - doFirst { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build profiling controller') - } - // Disable '-processing' because some annotations are not claimed. - // Disable '-options' because we are compiling for java8 without specifying bootstrap - intentionally. - // Disable '-path' because we do not have some of the paths seem to be missing. - options.compilerArgs.addAll(['-Xlint:all,-processing,-options,-path'/*, '-Werror'*/]) - options.fork = true - options.forkOptions.javaHome = file(System.env.JAVA_11_HOME) - } + setJavaVersion(it, 11) + // Disable '-processing' because some annotations are not claimed. + // Disable '-options' because we are compiling for java8 without specifying bootstrap - intentionally. + // Disable '-path' because we do not have some of the paths seem to be missing. + options.compilerArgs.addAll(['-Xlint:all,-processing,-options,-path'/*, '-Werror'*/]) } } diff --git a/dd-java-agent/agent-tooling/agent-tooling.gradle b/dd-java-agent/agent-tooling/agent-tooling.gradle index 6452cb242ee..33817df3f48 100644 --- a/dd-java-agent/agent-tooling/agent-tooling.gradle +++ b/dd-java-agent/agent-tooling/agent-tooling.gradle @@ -35,26 +35,27 @@ sourceSets { java.srcDirs "${project.projectDir}/src/main/java11" } } -compileMain_java11Java.doFirst { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build transformer helpers') - } - options.fork = true - options.forkOptions.javaHome = file(System.env.JAVA_11_HOME) - sourceCompatibility = JavaVersion.VERSION_1_9 - targetCompatibility = JavaVersion.VERSION_1_9 + +compileMain_java11Java.configure { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 + setJavaVersion(it, 11) } + dependencies { main_java11CompileOnly deps.bytebuddy main_java11CompileOnly sourceSets.main.output runtimeOnly sourceSets.main_java11.output } + jar { from sourceSets.main_java11.output } + forbiddenApisMain_java11 { failOnMissingClasses = false } + idea { module { jdkName = '11' diff --git a/dd-java-agent/appsec/weblog/weblog-common/weblog-common.gradle b/dd-java-agent/appsec/weblog/weblog-common/weblog-common.gradle index 0d1451db613..0126a948c8c 100644 --- a/dd-java-agent/appsec/weblog/weblog-common/weblog-common.gradle +++ b/dd-java-agent/appsec/weblog/weblog-common/weblog-common.gradle @@ -1,7 +1,7 @@ apply from: "$rootDir/gradle/java.gradle" -sourceCompatibility = 1.6 -targetCompatibility = 1.6 +sourceCompatibility = JavaVersion.VERSION_1_6 +targetCompatibility = JavaVersion.VERSION_1_6 dependencies { api 'javax.servlet:servlet-api:2.4' diff --git a/dd-java-agent/instrumentation/akka-http-10.0/akka-http-10.0.gradle b/dd-java-agent/instrumentation/akka-http-10.0/akka-http-10.0.gradle index 935d442431c..f10a9344b19 100644 --- a/dd-java-agent/instrumentation/akka-http-10.0/akka-http-10.0.gradle +++ b/dd-java-agent/instrumentation/akka-http-10.0/akka-http-10.0.gradle @@ -1,6 +1,7 @@ // Set properties before any plugins get loaded ext { minJavaVersionForTests = JavaVersion.VERSION_1_8 + lagomTestMaxJavaVersionForTests = JavaVersion.VERSION_1_8 } apply from: "$rootDir/gradle/java.gradle" @@ -23,13 +24,13 @@ testSets { } compileLagomTestJava { - sourceCompatibility = 1.8 - targetCompatibility = 1.8 + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 } compileLagomTestGroovy { - sourceCompatibility = 1.8 - targetCompatibility = 1.8 + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 } muzzle { diff --git a/dd-java-agent/instrumentation/exception-profiling/exception-profiling.gradle b/dd-java-agent/instrumentation/exception-profiling/exception-profiling.gradle index 5e1a42304e1..ac1a3e774cf 100644 --- a/dd-java-agent/instrumentation/exception-profiling/exception-profiling.gradle +++ b/dd-java-agent/instrumentation/exception-profiling/exception-profiling.gradle @@ -18,31 +18,12 @@ dependencies { testImplementation deps.mockito } -sourceCompatibility = JavaVersion.VERSION_1_7 -targetCompatibility = JavaVersion.VERSION_1_7 - // Must use Java 11 to build JFR enabled code - there is no JFR in OpenJDK 8 (revisit once JFR in Java 8 is available) [compileMain_java11Java, compileTestJava].each { it.sourceCompatibility = JavaVersion.VERSION_1_8 it.targetCompatibility = JavaVersion.VERSION_1_8 - it.doFirst { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build profiling instrumentation') - } - // Disable '-processing' because some annotations are not claimed. - // Disable '-options' because we are compiling for java8 without specifying bootstrap - intentionally. - // Disable '-path' because we do not have some of the paths seem to be missing. - // Compile to 8 compatible byte code - options.compilerArgs.addAll([ - '-source', - '8', - '-target', - '8', - '-Xlint:all,-processing,-options,-path' - ]) - options.fork = true - options.forkOptions.javaHome = file(System.env.JAVA_11_HOME) - } + setJavaVersion(it, 11) + it.options.compilerArgs.addAll(['-Xlint:all,-processing,-options,-path']) } idea { diff --git a/dd-java-agent/instrumentation/jax-rs-annotations-2/jax-rs-annotations-2.gradle b/dd-java-agent/instrumentation/jax-rs-annotations-2/jax-rs-annotations-2.gradle index e98fb95e904..685d1bfa260 100644 --- a/dd-java-agent/instrumentation/jax-rs-annotations-2/jax-rs-annotations-2.gradle +++ b/dd-java-agent/instrumentation/jax-rs-annotations-2/jax-rs-annotations-2.gradle @@ -1,3 +1,8 @@ +ext { + nestedTestMinJavaVersionForTests=JavaVersion.VERSION_1_8 + resteasy31TestMinJavaVersionForTests=JavaVersion.VERSION_1_8 +} + muzzle { fail { group = "javax.ws.rs" @@ -12,7 +17,6 @@ muzzle { } apply from: "$rootDir/gradle/java.gradle" - apply plugin: 'org.unbroken-dome.test-sets' testSets { @@ -41,10 +45,7 @@ dependencies { testImplementation group: 'javax.xml.bind', name: 'jaxb-api', version: '2.3.1' testImplementation group: 'com.fasterxml.jackson.module', name: 'jackson-module-afterburner', version: '2.9.10' - // Nested Resource Test fails Java 9+ without a xml impl - if (JavaVersion.current().isJava9Compatible()) { - nestedTestImplementation group: 'org.glassfish.jaxb', name: 'jaxb-runtime', version: '2.3.5' - } + nestedTestImplementation group: 'org.glassfish.jaxb', name: 'jaxb-runtime', version: '2.3.5' latestDepTestImplementation group: 'io.dropwizard', name: 'dropwizard-testing', version: '1.+' @@ -60,7 +61,6 @@ dependencies { latestDepTestImplementation group: 'org.jboss.resteasy', name: 'resteasy-jaxrs', version: '+' } -// These are only run with Java 8 on CI tasks.named("test").configure { dependsOn "resteasy31Test" dependsOn "nestedTest" diff --git a/dd-java-agent/instrumentation/jdbc/jdbc.gradle b/dd-java-agent/instrumentation/jdbc/jdbc.gradle index 00a4e0fa2e7..0d6bdeed4a4 100644 --- a/dd-java-agent/instrumentation/jdbc/jdbc.gradle +++ b/dd-java-agent/instrumentation/jdbc/jdbc.gradle @@ -78,10 +78,5 @@ tasks.named("test").configure { } tasks.named("latestDepJava11Test").configure { - doFirst { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set for latestDepJava11Test') - } - executable = file("${System.env.JAVA_11_HOME}/bin/java") - } + javaLauncher = getJavaLauncherFor(11) } diff --git a/dd-java-agent/instrumentation/jetty-11/jetty-11.gradle b/dd-java-agent/instrumentation/jetty-11/jetty-11.gradle index 6f75d74e4e4..7ea0c18bf26 100644 --- a/dd-java-agent/instrumentation/jetty-11/jetty-11.gradle +++ b/dd-java-agent/instrumentation/jetty-11/jetty-11.gradle @@ -29,28 +29,14 @@ sourceSets { [compileMain_java11Java, compileTestJava].each { it.configure { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build Java 11 code') - } - javaCompiler = javaToolchains.compilerFor { - languageVersion = JavaLanguageVersion.of(11) - sourceCompatibility = JavaVersion.VERSION_1_8 - targetCompatibility = JavaVersion.VERSION_1_8 - } + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 + setJavaVersion(it, 11) } } -[compileTestGroovy].each { - it.configure { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build Java 11 code') - } - javaLauncher = javaToolchains.launcherFor { - languageVersion = JavaLanguageVersion.of(11) - sourceCompatibility = JavaVersion.VERSION_1_8 - targetCompatibility = JavaVersion.VERSION_1_8 - } - } +compileTestGroovy { + javaLauncher = getJavaLauncherFor(11) } dependencies { diff --git a/dd-smoke-tests/java9-modules/java9-modules.gradle b/dd-smoke-tests/java9-modules/java9-modules.gradle index 3a8555fffb7..ddb156c6f38 100644 --- a/dd-smoke-tests/java9-modules/java9-modules.gradle +++ b/dd-smoke-tests/java9-modules/java9-modules.gradle @@ -1,5 +1,5 @@ ext { - minJavaVersionForTests = JavaVersion.VERSION_1_9 + minJavaVersionForTests = JavaVersion.VERSION_11 } apply from: "$rootDir/gradle/java.gradle" @@ -10,60 +10,30 @@ jar { } } -// If the current JDK version (the one running gradle) is < 9, we need to find a version >= 9 -// to compile this project. java.gradle creates a map of java executables -// called "javaExecutableVersionCache" pulled from the environment. -// This loops over the cache to find a usable jdk. -// Since this project is the only one that requires a version above Java 8 -// it's special cased here instead of putting a generic version matcher in java.gradle -if (JavaVersion.VERSION_1_9.compareTo(JavaVersion.current()) > 0) { - def targetJavaHome +sourceCompatibility = JavaVersion.VERSION_1_8 +targetCompatibility = JavaVersion.VERSION_1_8 - // Find a compatible version in the cache - ext.javaExecutableVersionCache.find { key, value -> - if (JavaVersion.VERSION_1_9.compareTo(value) <= 0) { - // JAVA_HOME/bin/java -> JAVA_HOME - targetJavaHome = file(key).parentFile.parentFile - return true - } - - return false - } - - if (targetJavaHome != null) { - // if we found a compatible jdk, compile the src/main/java9 folder with it - compileMain_java9Java { - options.fork = true - options.forkOptions.javaHome = targetJavaHome - options.compilerArgs = ['--module-path', classpath.asPath] - options.sourcepath = files(sourceSets.main_java9.java.srcDirs) - } - } else { - compileMain_java9Java { - enabled = false - } +[JavaCompile, GroovyCompile].each { + tasks.withType(it).configureEach { + setJavaVersion(it, 11) + options.compilerArgs = ['--module-path', classpath.asPath] } } -// java.gradle generates a test task per jdk and assigns the test task its own java executable -// For each Test task, this loop creates a jlink image using the test's executable -// At the end, we have 1 jlink image per JVM: each one used by a testXXXGenerated task tasks.withType(Test).configureEach { - def javaExecutable = it.executable - def javaVersion = getJavaExecutableVersion(javaExecutable) - - // Only Java 9 and above have jlink - if (JavaVersion.VERSION_1_9.compareTo(javaVersion) > 0) { - return - } + dependsOn "jar" +} - // JAVA_HOME/bin/java -> JAVA_HOME - def specificJDKHome = file(javaExecutable).parentFile.parent - def jlinkExecutable = specificJDKHome + "/bin/jlink" - def jdkModulesPath = specificJDKHome + "/jmods" - def generatedImageDir = "${buildDir}/${it.name}image" +tasks.withType(Test).forEach { + it.doFirst { + JavaInstallationMetadata metadata = it.getJavaLauncher().get().metadata + // We can safely assume that the general configuration has disabled this test if + // the JVM version is not 11+ + Directory specificJDKHome = metadata.installationPath + def jlinkExecutable = specificJDKHome.file("bin/jlink") + def jdkModulesPath = specificJDKHome.dir("jmods") + def generatedImageDir = "${buildDir}/${it.name}image" - doFirst { delete generatedImageDir // Run the jlink command to create the image @@ -72,10 +42,9 @@ tasks.withType(Test).configureEach { '--add-modules', 'java.instrument,datadog.smoketest.moduleapp', "--module-path", "${jdkModulesPath}:" + jar.archiveFile.get().toString(), "--output", generatedImageDir } - } - jvmArgs "-Ddatadog.smoketest.module.image=${generatedImageDir}" - dependsOn "jar" + it.jvmArgs "-Ddatadog.smoketest.module.image=${generatedImageDir}" + } } dependencies { diff --git a/dd-smoke-tests/java9-modules/src/main/java9/datadog/smoketest/moduleapp/ModuleApplication.java b/dd-smoke-tests/java9-modules/src/main/java11/datadog/smoketest/moduleapp/ModuleApplication.java similarity index 100% rename from dd-smoke-tests/java9-modules/src/main/java9/datadog/smoketest/moduleapp/ModuleApplication.java rename to dd-smoke-tests/java9-modules/src/main/java11/datadog/smoketest/moduleapp/ModuleApplication.java diff --git a/dd-smoke-tests/java9-modules/src/main/java9/module-info.java b/dd-smoke-tests/java9-modules/src/main/java11/module-info.java similarity index 100% rename from dd-smoke-tests/java9-modules/src/main/java9/module-info.java rename to dd-smoke-tests/java9-modules/src/main/java11/module-info.java diff --git a/dd-smoke-tests/profiling-integration-tests/profiling-integration-tests.gradle b/dd-smoke-tests/profiling-integration-tests/profiling-integration-tests.gradle index 9add10ce27c..dd938932dff 100644 --- a/dd-smoke-tests/profiling-integration-tests/profiling-integration-tests.gradle +++ b/dd-smoke-tests/profiling-integration-tests/profiling-integration-tests.gradle @@ -5,8 +5,7 @@ plugins { ext { enableJunitPlatform = true minJavaVersionForTests = JavaVersion.VERSION_1_8 - // Oracle 8 has JFR 1 and Zulu has backported JFR 2 - forceJdk = ['ZULU8', 'ORACLE8'] + excludeJdk = ['IBM8'] } apply from: "$rootDir/gradle/java.gradle" @@ -34,8 +33,5 @@ dependencies { tasks.withType(Test).configureEach { dependsOn "shadowJar" - - onlyIf { !name.contains('IBM') } - jvmArgs "-Ddatadog.smoketest.profiling.shadowJar.path=${tasks.shadowJar.archivePath}" } diff --git a/dd-trace-core/jfr-openjdk/jfr-openjdk.gradle b/dd-trace-core/jfr-openjdk/jfr-openjdk.gradle index 5c97b77dc0b..12bde5db6ab 100644 --- a/dd-trace-core/jfr-openjdk/jfr-openjdk.gradle +++ b/dd-trace-core/jfr-openjdk/jfr-openjdk.gradle @@ -30,17 +30,11 @@ targetCompatibility = JavaVersion.VERSION_1_8 [JavaCompile, GroovyCompile].each { tasks.withType(it).configureEach { - doFirst { - if (!System.env.JAVA_11_HOME) { - throw new GradleException('JAVA_11_HOME must be set to build profiling helpers') - } - // Disable '-processing' because some annotations are not claimed. - // Disable '-options' because we are compiling for java8 without specifying bootstrap - intentionally. - // Disable '-path' because we do not have some of the paths seem to be missing. - options.compilerArgs.addAll(['-Xlint:all,-processing,-options,-path', '-Werror']) - options.fork = true - options.forkOptions.javaHome = file(System.env.JAVA_11_HOME) - } + setJavaVersion(it, 11) + // Disable '-processing' because some annotations are not claimed. + // Disable '-options' because we are compiling for java8 without specifying bootstrap - intentionally. + // Disable '-path' because we do not have some of the paths seem to be missing. + options.compilerArgs.addAll(['-Xlint:all,-processing,-options,-path', '-Werror']) } } diff --git a/gradle.properties b/gradle.properties index 708baea46fa..f285f9cff2d 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,4 +2,7 @@ org.gradle.parallel=true org.gradle.caching=true org.gradle.jvmargs=-XX:MaxMetaspaceSize=1g -org.gradle.java.installations.fromEnv=JAVA_7_HOME,JAVA_8_HOME,JAVA_11_HOME,JAVA_13_HOME,JAVA_15_HOME +org.gradle.java.installations.auto-detect=false +org.gradle.java.installations.auto-download=false +# 8 and 11 is needed to build +org.gradle.java.installations.fromEnv=JAVA_8_HOME,JAVA_11_HOME diff --git a/gradle/java_no_deps.gradle b/gradle/java_no_deps.gradle index 19597f08e50..a980c6ba9d5 100644 --- a/gradle/java_no_deps.gradle +++ b/gradle/java_no_deps.gradle @@ -1,4 +1,5 @@ import java.time.Duration +import org.gradle.jvm.toolchain.internal.SpecificInstallationToolchainSpec apply plugin: 'java-library' @@ -38,8 +39,8 @@ if (applyCodeCoverage) { apply from: "$rootDir/gradle/jacoco.gradle" } -sourceCompatibility = 1.7 -targetCompatibility = 1.7 +sourceCompatibility = JavaVersion.VERSION_1_7 +targetCompatibility = JavaVersion.VERSION_1_7 // when building with Java 9+, lazily set compiler --release flag to match target def skipSettingCompilerRelease = project.findProperty('skipSettingCompilerRelease') @@ -169,8 +170,54 @@ javadoc { } project.afterEvaluate { - if (project.plugins.hasPlugin('org.unbroken-dome.test-sets') && configurations.hasProperty("latestDepTestRuntime")) { - tasks.withType(Test).configureEach { + def testJvm = gradle.startParameter.projectProperties["testJvm"] + def javaTestLauncher = null as Provider + if (testJvm) { + def matcher = testJvm =~ /([a-zA-Z]*)([0-9]+)/ + if (!matcher.matches()) { + throw new GradleException("Unable to find launcher for Java '$testJvm'. It needs to match '([a-zA-Z]*)([0-9]+)'.") + } + def testJvmLanguageVersion = matcher.group(2) as Integer + def testJvmEnv = "JAVA_${testJvm}_HOME" + def testJvmHome = System.getenv(testJvmEnv) + if (!testJvmHome) { + throw new GradleException("Unable to find launcher for Java '$testJvm'. Have you set '$testJvmEnv'?") + } + def jvmSpec = new SpecificInstallationToolchainSpec(project.getObjects(), file(testJvmHome)) + // Not really sure why this has to be done forcefully, but if it's not then gradle will complain that + // javaLauncher.metadata.taskInputs.languageVersion doesn't have a configured value (even though it is + // populated automatically by the javaToolchainsService) + jvmSpec.languageVersion.set(JavaLanguageVersion.of(testJvmLanguageVersion)) + // The provider always says that a value is present so we need to wrap it for proper error messages + Provider launcher = providers.provider { + try { + return javaToolchains.launcherFor(jvmSpec).get() + } catch (NoSuchElementException ignored) { + throw new GradleException("Unable to find launcher for Java $testJvm. Does '$testJvmHome' point to a JDK?") + } + } + javaTestLauncher = launcher + } + + tasks.withType(Test).configureEach { + if (javaTestLauncher) { + def metadata = javaTestLauncher.get().metadata + def allowedOrForced = !isJdkExcluded(testJvm) && + (isJavaLanguageVersionAllowed(metadata.languageVersion, it.name) || isJdkForced(testJvm)) + javaLauncher = javaTestLauncher + onlyIf {allowedOrForced } + if (applyCodeCoverage) { + jacoco { + // Disable jacoco for additional JVM tests to speed things up a bit + enabled = false + } + } + } else { + def name = it.name + onlyIf { isJavaVersionAllowed(JavaVersion.current(), name) } + } + + if (project.plugins.hasPlugin('org.unbroken-dome.test-sets') && configurations.hasProperty("latestDepTestRuntime")) { doFirst { def testArtifacts = configurations.testRuntimeClasspath.resolvedConfiguration.resolvedArtifacts def latestTestArtifacts = configurations.latestDepTestRuntimeClasspath.resolvedConfiguration.resolvedArtifacts @@ -203,116 +250,62 @@ if (project.hasProperty("removeJarVersionNumbers") && removeJarVersionNumbers) { } } -if (project.parent && project.parent.properties.containsKey('javaExecutableVersionCache')) { - project.ext.javaExecutableVersionCache = project.parent.properties.get('javaExecutableVersionCache') -} else { - project.ext.javaExecutableVersionCache = [:] -} - -JavaVersion getJavaExecutableVersion(String path) { - def cache = project.ext.javaExecutableVersionCache - - if (cache.containsKey(path)) { - return cache.get(path) +ext.setJavaVersion = (it, javaVersionInteger) -> { + AbstractCompile ac = (AbstractCompile) it + Provider compiler = javaToolchains.compilerFor { + languageVersion = JavaLanguageVersion.of(javaVersionInteger) } - new ByteArrayOutputStream().withStream { stream -> - exec { - commandLine = [path, "-version"] - errorOutput = stream - } - def matcher = stream.toString() =~ /^(?:java|openjdk) version "([^"]+)"/ - if (matcher) { - def version = JavaVersion.toVersion(matcher.group(1)) - cache.put(path, version) - return version - } else { - throw new GradleScriptException("Cannot determine java version: ${stream.toString}") + try { + ac.configure { + options.fork = true + options.forkOptions.javaHome = compiler.get().metadata.installationPath.asFile } + } catch (NoSuchElementException ignored) { + throw new GradleException("Unable to find compiler for Java $javaVersionInteger. Have you set JAVA_${javaVersionInteger}_HOME?") } -} +} as Closure -ext { - getJavaExecutableVersion = this.&getJavaExecutableVersion -} +ext.getJavaLauncherFor = (javaVersionInteger) -> { + def launcher = javaToolchains.launcherFor { + languageVersion = JavaLanguageVersion.of(javaVersionInteger) + } + if (!launcher.present) { + throw new GradleException("Unable to find launcher for Java $javaVersionInteger. Have you set JAVA_${javaVersionInteger}_HOME?") + } + return launcher +} as Closure> -def isJavaVersionAllowed(JavaVersion version) { - if (project.hasProperty('minJavaVersionForTests') && project.getProperty('minJavaVersionForTests').compareTo(version) > 0) { +def isJavaVersionAllowedForProperty(JavaVersion version, String propertyPrefix = "") { + def minProp = propertyPrefix.isEmpty() ? 'minJavaVersionForTests' : "${propertyPrefix}MinJavaVersionForTests" + def maxProp = propertyPrefix.isEmpty() ? 'maxJavaVersionForTests' : "${propertyPrefix}MaxJavaVersionForTests" + if (project.hasProperty(minProp) && project.getProperty(minProp).compareTo(version) > 0) { return false } - if (project.hasProperty('maxJavaVersionForTests') && project.getProperty('maxJavaVersionForTests').compareTo(version) < 0) { + if (project.hasProperty(maxProp) && project.getProperty(maxProp).compareTo(version) < 0) { return false } return true } -def isJdkForced(String javaName) { - return (project.hasProperty('forceJdk') && project.getProperty('forceJdk').contains(javaName)) +def isJavaVersionAllowed(JavaVersion version, String testTaskName) { + return isJavaVersionAllowedForProperty(version) && isJavaVersionAllowedForProperty(version, testTaskName) } -def isTestingInstrumentation(Project project) { - return ["junit-4.10", "testng-6.4", "junit-5.3"].contains(project.name) +def isJavaLanguageVersionAllowed(JavaLanguageVersion languageVersion, String testTaskName) { + def version = JavaVersion.toVersion(languageVersion.asInt()) + return isJavaVersionAllowed(version, testTaskName) } -// This is slightly complicated because we need to dereference symlinks to make sure -// we are considering same JVM implementation -def currentJavaHome = new File(System.getProperty("java.home")).toPath().toRealPath() -if (currentJavaHome.endsWith("jre")) { - currentJavaHome = currentJavaHome.parent +def isJdkForced(String javaName) { + return (project.hasProperty('forceJdk') && project.getProperty('forceJdk').contains(javaName)) } -// Generate tests tasks for all provided JVMs -for (def env : System.getenv().entrySet()) { - def matcher = env.key =~ /JAVA_([^_]+)_HOME/ - if (!matcher) { - continue - } - def javaName = matcher.group(1) - def javaHome = env.value - def javaPath = "$javaHome/bin/java" - def javaVersion = getJavaExecutableVersion(javaPath) - - if (currentJavaHome == new File(javaHome).toPath().toRealPath()) { - // Skip JVM implementation we are running gradle on - continue - } - - def parentTask = tasks.register("testJava${javaName}") { - group = 'Verification' - description = "Run tests for Java ${javaName}" - } - tasks.named('check').configure { - dependsOn parentTask - } - - tasks.withType(Test).all { - //if (name.endsWith("Generated")) { - if (!name.equals("test") && !name.equals("forkedTest")) { - // The way we're copying the test doesn't currently work with "test-sets" generated tests. - return - } - - def clonedTask = it - def newTask = tasks.register("${clonedTask.name}Java${javaName}Generated", clonedTask.class) { - description "Runs $clonedTask.name under java ${javaName}" - executable = javaPath - - if (javaName == "7") { - // Disable JIT for this method. Sometimes Java7 JVM crashes trying to compile it. - jvmArgs '-XX:CompileCommand=exclude,net.bytebuddy.description.type.TypeDescription$Generic$Visitor$Substitutor::onParameterizedType' - } +def isJdkExcluded(String javaName) { + return (project.hasProperty('excludeJdk') && project.getProperty('excludeJdk').contains(javaName)) +} - onlyIf { isJavaVersionAllowed(javaVersion) || isJdkForced(javaName) } - if (applyCodeCoverage) { - jacoco { - // Disable jacoco for additional JVM tests to speed things up a bit - enabled = false - } - } - } - parentTask.configure { - dependsOn newTask - } - } +def isTestingInstrumentation(Project project) { + return ["junit-4.10", "testng-6.4", "junit-5.3"].contains(project.name) } // Go through the Test tasks and configure them @@ -361,11 +354,4 @@ tasks.withType(Test).configureEach { } else { exclude("**/*ForkedTest*") } - - // Disable default test tasks if the current JVM doesn't match version requirements - if (!name.endsWith("Generated")) { - // Always run all tests that are runnable on JVM used for compilation - onlyIf { isJavaVersionAllowed(JavaVersion.current()) } - it.executable = "$currentJavaHome/bin/java" - } } diff --git a/utils/test-agent-utils/decoder/decoder.gradle b/utils/test-agent-utils/decoder/decoder.gradle index 569265ebd17..6626f8892ae 100644 --- a/utils/test-agent-utils/decoder/decoder.gradle +++ b/utils/test-agent-utils/decoder/decoder.gradle @@ -1,8 +1,5 @@ apply from: "$rootDir/gradle/java_no_deps.gradle" -sourceCompatibility = JavaVersion.VERSION_1_7 -targetCompatibility = JavaVersion.VERSION_1_7 - ext { minimumInstructionCoverage = 0.7 excludedClassesCoverage = ['datadog.trace.test.agent.decoder.v04.raw.*', 'datadog.trace.test.agent.decoder.v05.raw.*',]