Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix Gradle toolchain issues

This commit is contained in:
Christian Beikov 2023-08-15 19:35:08 +02:00
parent ffe13dde30
commit 7c697f7e37
7 changed files with 68 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
gradle/java-module.gradle
View File

@ -177,26 +177,6 @@ if ( toolsJar.exists() ) {
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Testing
if ( jdkVersions.explicitlyConfigured ) {
tasks.test {
// Configure version of Java tools
javaLauncher = javaToolchains.launcherFor {
languageVersion = gradle.ext.javaVersions.test.launcher
}
// Configure JVM Options
jvmArgs( getProperty( 'toolchain.launcher.jvmargs' ).toString().split( ' ' ) )
if ( project.hasProperty( 'test.jdk.launcher.args' ) ) {
jvmArgs( project.getProperty( 'test.jdk.launcher.args' ).toString().split( ' ' ) )
}
// Display version of Java tools
doFirst {
logger.lifecycle "Testing with '${javaLauncher.get().metadata.installationPath}'"
}
}
}
class HeapDumpPathProvider implements CommandLineArgumentProvider {
@OutputDirectory
Provider<Directory> path

6
hibernate-core/hibernate-core.gradle
View File

@ -271,7 +271,7 @@ if ( jdkVersions.test.release.asInt() >= 17 && jdkVersions.explicit ) {
// For the new source set, we need to configure the source and target version to 17
compileTestJava17Java {
javaCompiler = javaToolchains.compilerFor {
languageVersion = gradle.ext.javaVersions.test.compiler
languageVersion = jdkVersions.test.compiler
}
sourceCompatibility = 17
targetCompatibility = 17
@ -295,13 +295,13 @@ if ( jdkVersions.test.release.asInt() >= 17 && jdkVersions.explicit ) {
// We execute the Java 17 tests in a custom test task
task testJava17(type: Test) {
javaLauncher = javaToolchains.launcherFor {
languageVersion = gradle.ext.javaVersions.test.launcher
languageVersion = jdkVersions.test.launcher
}
useJUnitPlatform()
testClassesDirs = sourceSets.testJava17.output.classesDirs
classpath = sourceSets.testJava17.runtimeClasspath
if ( gradle.ext.javaVersions.test.launcher.asInt() >= 19 ) {
if ( jdkVersions.test.launcher.asInt() >= 19 ) {
logger.warn( "The version of Java bytecode that will be tested is not supported by Byte Buddy by default. " +
" Setting 'net.bytebuddy.experimental=true'." )
systemProperty 'net.bytebuddy.experimental', true

2
local-build-plugins/src/main/java/org/hibernate/orm/post/LoggingReportTask.java
View File

@ -122,7 +122,7 @@ public abstract class LoggingReportTask extends AbstractJandexAwareTask {
private IdRange calculateIdRange(AnnotationInstance msgLoggerAnnUsage, SubSystem subSystem) {
final ClassInfo loggerClassInfo = msgLoggerAnnUsage.target().asClass();
getProject().getLogger().lifecycle( "MessageLogger (`%s`) missing id-range", loggerClassInfo.simpleName() );
getProject().getLogger().lifecycle( "MessageLogger (`{}`) missing id-range", loggerClassInfo.simpleName() );
final List<AnnotationInstance> messageAnnUsages = loggerClassInfo.annotations( MSG_ANN_NAME );
if ( messageAnnUsages.isEmpty() ) {

57
local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java
View File

@ -22,6 +22,7 @@ import org.gradle.api.tasks.SourceSetContainer;
import org.gradle.api.tasks.compile.CompileOptions;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.api.tasks.javadoc.Javadoc;
import org.gradle.api.tasks.testing.Test;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.gradle.jvm.toolchain.JavaToolchainService;
@ -50,6 +51,7 @@ public class JavaModulePlugin implements Plugin<Project> {
final JavaCompile mainCompileTask = (JavaCompile) project.getTasks().getByName( mainSourceSet.getCompileJavaTaskName() );
final JavaCompile testCompileTask = (JavaCompile) project.getTasks().getByName( testSourceSet.getCompileJavaTaskName() );
final Test testTask = (Test) project.getTasks().findByName( testSourceSet.getName() );
if ( !jdkVersionsConfig.isExplicitlyConfigured() ) {
mainCompileTask.setSourceCompatibility( jdkVersionsConfig.getMainReleaseVersion().toString() );
@ -63,6 +65,7 @@ public class JavaModulePlugin implements Plugin<Project> {
configureCompileTasks( project );
configureJavadocTasks( project );
configureTestTasks( project );
configureCompileTask( mainCompileTask, jdkVersionsConfig.getMainReleaseVersion() );
configureCompileTask( testCompileTask, jdkVersionsConfig.getTestReleaseVersion() );
@ -72,6 +75,13 @@ public class JavaModulePlugin implements Plugin<Project> {
javaToolchainSpec.getLanguageVersion().set( jdkVersionsConfig.getTestCompileVersion() );
} )
);
if ( testTask != null ) {
testTask.getJavaLauncher().set(
toolchainService.launcherFor( javaToolchainSpec -> {
javaToolchainSpec.getLanguageVersion().set( jdkVersionsConfig.getTestLauncherVersion() );
} )
);
}
}
}
@ -97,7 +107,7 @@ public class JavaModulePlugin implements Plugin<Project> {
@Override
public void execute(Task task) {
project.getLogger().lifecycle(
"Compiling with '%s'",
"Compiling with '{}'",
compileTask.getJavaCompiler().get().getMetadata().getInstallationPath()
);
}
@ -116,7 +126,7 @@ public class JavaModulePlugin implements Plugin<Project> {
@Override
public void execute(Task task) {
project.getLogger().lifecycle(
"Generating javadoc with '%s'",
"Generating javadoc with '{}}'",
javadocTask.getJavadocTool().get().getMetadata().getInstallationPath()
);
}
@ -125,6 +135,37 @@ public class JavaModulePlugin implements Plugin<Project> {
} );
}
private void configureTestTasks(Project project) {
project.getTasks().withType( Test.class ).configureEach( new Action<Test>() {
@Override
public void execute(Test testTask) {
getJvmArgs( testTask ).addAll(
Arrays.asList(
project.property( "toolchain.launcher.jvmargs" ).toString().split( " " )
)
);
if ( project.hasProperty( "test.jdk.launcher.args" ) ) {
getJvmArgs( testTask ).addAll(
Arrays.asList(
project.getProperties().get( "test.jdk.launcher.args" ).toString().split( " " )
)
);
}
testTask.doFirst(
new Action<Task>() {
@Override
public void execute(Task task) {
project.getLogger().lifecycle(
"Testing with '{}'",
testTask.getJavaLauncher().get().getMetadata().getInstallationPath()
);
}
}
);
}
} );
}
private static List<String> javadocFlags(Project project) {
final String jvmArgs = project.property( "toolchain.javadoc.jvmargs" ).toString();
final String[] splits = jvmArgs.split( " " );
@ -145,4 +186,16 @@ public class JavaModulePlugin implements Plugin<Project> {
return existing;
}
}
public static List<String> getJvmArgs(Test testTask) {
final List<String> existing = testTask.getJvmArgs();
if ( existing == null || !( existing instanceof ArrayList ) ) {
final List<String> target = new ArrayList<>();
testTask.setJvmArgs( target );
return target;
}
else {
return existing;
}
}
}

8
local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java
View File

@ -124,10 +124,10 @@ public class JdkVersionConfig {
testCompileVersion = requireNonNullElse( explicitTestVersion, baselineJdkVersion );
mainReleaseVersion = baselineJdkVersion;
if ( testCompileVersion.asInt() > gradleJdkVersion.asInt() ) {
if ( testCompileVersion.asInt() > maxSupportedJdkVersion.asInt() ) {
System.out.println(
"[WARN] Gradle does not support bytecode version '${testCompilerVersion}'."
+ " Forcing test bytecode to version ${GRADLE_MAX_SUPPORTED_BYTECODE_VERSION}."
"[WARN] Gradle does not support bytecode version '" + testCompileVersion + "'."
+ " Forcing test bytecode to version " + maxSupportedJdkVersion + "."
);
testReleaseVersion = maxSupportedJdkVersion;
}
@ -138,7 +138,7 @@ public class JdkVersionConfig {
testLauncherVersion = testCompileVersion;
return new JdkVersionConfig(
false,
true,
baselineJdkVersion,
mainCompileVersion,
mainReleaseVersion,

4
tooling/hibernate-gradle-plugin/hibernate-gradle-plugin.gradle
View File

@ -130,8 +130,8 @@ tasks.withType( JavaCompile ) {
if ( !jdkVersions.explicit ) {
tasks.withType( GroovyCompile ) {
sourceCompatibility = JavaVersion.toVersion( gradle.jdkVersions.baseline )
targetCompatibility = JavaVersion.toVersion( gradle.jdkVersions.baseline )
sourceCompatibility = JavaVersion.toVersion( jdkVersions.baseline )
targetCompatibility = JavaVersion.toVersion( jdkVersions.baseline )
}
}
else {

6
tooling/metamodel-generator/hibernate-jpamodelgen.gradle
View File

@ -53,7 +53,7 @@ if ( jdkVersions.test.release.asInt() >= 17 && jdkVersions.explicit ) {
//compileTestJava17Java {
compileTestJava {
javaCompiler = javaToolchains.compilerFor {
languageVersion = gradle.jdkVersions.test.compile
languageVersion = jdkVersions.test.compile
}
sourceCompatibility = 17
targetCompatibility = 17
@ -61,10 +61,10 @@ if ( jdkVersions.test.release.asInt() >= 17 && jdkVersions.explicit ) {
test {
javaLauncher = javaToolchains.launcherFor {
languageVersion = gradle.ext.javaVersions.test.launcher
languageVersion = jdkVersions.test.launcher
}
if ( gradle.ext.javaVersions.test.launcher.asInt() >= 19 ) {
if ( jdkVersions.test.launcher.asInt() >= 19 ) {
logger.warn( "The version of Java bytecode that will be tested is not supported by Bytebuddy by default. " +
" Setting 'net.bytebuddy.experimental=true'." )
systemProperty 'net.bytebuddy.experimental', true