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

General Gradle work - toolchains

This commit is contained in:
Steve Ebersole 2023-08-07 20:05:47 -05:00
parent f49b87600e
commit 306adef2a7
13 changed files with 644 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
build.gradle
View File

@ -26,6 +26,7 @@ plugins {
id 'biz.aQute.bnd' version '6.3.1' apply false
id 'org.checkerframework' version '0.6.25'
id 'org.hibernate.orm.build.jdks'
id 'io.github.gradle-nexus.publish-plugin' version '1.1.0'
@ -46,9 +47,7 @@ task release {
"themselves if they have any release-related activities to perform"
doFirst {
def javaVersionsInUse = [gradle.ext.javaVersions.main.compiler, gradle.ext.javaVersions.main.release,
gradle.ext.javaVersions.test.compiler, gradle.ext.javaVersions.test.release,
gradle.ext.javaVersions.test.launcher].toSet()
def javaVersionsInUse = jdkVersions.allVersions
if ( javaVersionsInUse != [JavaLanguageVersion.of( 11 )].toSet() ) {
throw new IllegalStateException( "Please use JDK 11 to perform the release. Currently using: ${javaVersionsInUse}" )
}

61
gradle/java-module.gradle
View File

@ -25,11 +25,10 @@ apply from: rootProject.file( 'gradle/module.gradle' )
apply from: rootProject.file( 'gradle/libraries.gradle' )
apply from: rootProject.file( 'gradle/databases.gradle' )
apply plugin: 'org.hibernate.orm.database-service'
apply plugin: 'java-library'
apply plugin: 'biz.aQute.bnd.builder'
apply plugin: 'org.hibernate.orm.database-service'
apply plugin: 'org.hibernate.orm.build.java-module'
apply plugin: 'org.checkerframework'
@ -159,58 +158,6 @@ tasks.withType( JavaCompile ) {
// ]
}
if ( !gradle.ext.javaToolchainEnabled ) {
tasks.compileJava.configure {
sourceCompatibility = JavaVersion.toVersion( gradle.ext.javaVersions.main.release )
targetCompatibility = JavaVersion.toVersion( gradle.ext.javaVersions.main.release )
}
tasks.compileTestJava.configure {
sourceCompatibility = JavaVersion.toVersion( gradle.ext.javaVersions.test.release )
targetCompatibility = JavaVersion.toVersion( gradle.ext.javaVersions.test.release )
}
}
else {
// Configure generated bytecode
// "sourceCompatibility" is not supported with toolchains. We have to work around that limitation.
tasks.compileJava.configure {
options.release = gradle.ext.javaVersions.main.release.asInt()
// Needs add-opens because of https://github.com/gradle/gradle/issues/15538
options.forkOptions.jvmArgs.addAll( ["--add-opens", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED"] )
}
tasks.compileTestJava.configure {
options.release = gradle.ext.javaVersions.test.release.asInt()
// Needs add-opens because of https://github.com/gradle/gradle/issues/15538
options.forkOptions.jvmArgs.addAll( ["--add-opens", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED"] )
}
// Configure version of Java tools
java {
toolchain {
languageVersion = gradle.ext.javaVersions.main.compiler
}
}
tasks.compileTestJava {
javaCompiler = javaToolchains.compilerFor {
languageVersion = gradle.ext.javaVersions.test.compiler
}
}
// Configure JVM Options
// Display version of Java tools
tasks.withType( JavaCompile ).configureEach {
options.forkOptions.jvmArgs.addAll( getProperty( 'toolchain.compiler.jvmargs' ).toString().split( ' ' ) )
doFirst {
logger.lifecycle "Compiling with '${javaCompiler.get().metadata.installationPath}'"
}
}
tasks.withType( Javadoc ).configureEach {
options.setJFlags( getProperty( 'toolchain.javadoc.jvmargs' ).toString().split( ' ' ).toList().findAll( { !it.isEmpty() } ) )
doFirst {
logger.lifecycle "Generating javadoc with '${javadocTool.get().metadata.installationPath}'"
}
}
}
task compile(dependsOn: [compileJava, processResources, compileTestJava, processTestResources] )
@ -231,7 +178,7 @@ if ( toolsJar.exists() ) {
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Testing
if ( gradle.ext.javaToolchainEnabled ) {
if ( jdkVersions.explicitlyConfigured ) {
tasks.test {
// Configure version of Java tools
javaLauncher = javaToolchains.launcherFor {
@ -363,7 +310,7 @@ test {
// and those classes always have bytecode matching the version of the launcher.
// So for example, when using a JDK19 launcher and compiling tests with --release 17,
// Bytebuddy will still encounter classes with Java 19 bytecode.
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
@ -556,7 +503,7 @@ task forbiddenApisSystemOut(type: CheckForbiddenApis, dependsOn: compileJava) {
}
task forbiddenApisUnsafe(type: CheckForbiddenApis, dependsOn: compileJava) {
bundledSignatures += "jdk-unsafe-${gradle.ext.baselineJavaVersion}".toString()
bundledSignatures += "jdk-unsafe-${jdkVersions.baseline}".toString()
// unfortunately we currently have many uses of default Locale implicitly (~370) which need to be fixed
// before we can fully enabled this check

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

@ -254,7 +254,7 @@ tasks.withType( Test.class ).each { test ->
}
// Tests with records
if ( gradle.ext.javaVersions.test.release.asInt() >= 17 && gradle.ext.javaToolchainEnabled ) {
if ( jdkVersions.test.release.asInt() >= 17 && jdkVersions.explicit ) {
// Add a new source set, which contains tests that can run on JDK17+
sourceSets {

8
local-build-plugins/build.gradle
View File

@ -68,6 +68,14 @@ gradlePlugin {
id = 'org.hibernate.orm.build.properties'
implementationClass = 'org.hibernate.orm.properties.ConfigPropertyCollectorPlugin'
}
jdkVersionsPlugin {
id = 'org.hibernate.orm.build.jdks'
implementationClass = 'org.hibernate.orm.toolchains.JdkVersionPlugin'
}
javaModulePlugin {
id = 'org.hibernate.orm.build.java-module'
implementationClass = 'org.hibernate.orm.toolchains.JavaModulePlugin'
}
}
}

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

@ -0,0 +1,151 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html.
*/
package org.hibernate.orm.toolchains;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import javax.inject.Inject;
import org.gradle.api.Action;
import org.gradle.api.JavaVersion;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.api.tasks.javadoc.Javadoc;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.gradle.jvm.toolchain.JavaToolchainService;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import static java.util.Arrays.asList;
/**
* @author Steve Ebersole
*/
public class JavaModulePlugin implements Plugin<Project> {
private final JavaToolchainService toolchainService;
@Inject
public JavaModulePlugin(JavaToolchainService toolchainService) {
this.toolchainService = toolchainService;
}
@Override
public void apply(Project project) {
project.getPluginManager().apply( JdkVersionPlugin.class );
final JdkVersionConfig jdkVersionsConfig = project.getExtensions().getByType( JdkVersionConfig.class );
final JavaPluginExtension javaPluginExtension = project.getExtensions().getByType( JavaPluginExtension.class );
final SourceSetContainer sourceSets = javaPluginExtension.getSourceSets();
final SourceSet mainSourceSet = sourceSets.getByName( SourceSet.MAIN_SOURCE_SET_NAME );
final SourceSet testSourceSet = sourceSets.getByName( SourceSet.TEST_SOURCE_SET_NAME );
final JavaCompile mainCompileTask = (JavaCompile) project.getTasks().getByName( mainSourceSet.getCompileJavaTaskName() );
mainCompileTask.setSourceCompatibility( jdkVersionsConfig.getTestCompileVersion().toString() );
mainCompileTask.setTargetCompatibility( jdkVersionsConfig.getTestCompileVersion().toString() );
final JavaCompile testCompileTask = (JavaCompile) project.getTasks().getByName( testSourceSet.getCompileJavaTaskName() );
testCompileTask.setSourceCompatibility( jdkVersionsConfig.getTestCompileVersion().toString() );
testCompileTask.setTargetCompatibility( jdkVersionsConfig.getTestCompileVersion().toString() );
if ( jdkVersionsConfig.isExplicit() ) {
javaPluginExtension.getToolchain().getLanguageVersion().set( jdkVersionsConfig.getMainCompileVersion() );
prepareCompileTask( mainCompileTask, jdkVersionsConfig.getMainCompileVersion() );
prepareCompileTask( testCompileTask, jdkVersionsConfig.getTestCompileVersion() );
testCompileTask.getJavaCompiler().set(
toolchainService.compilerFor( new Action<JavaToolchainSpec>() {
@Override
public void execute(JavaToolchainSpec javaToolchainSpec) {
javaToolchainSpec.getLanguageVersion().set( jdkVersionsConfig.getTestCompileVersion() );
}
} )
);
project.getTasks().withType( JavaCompile.class ).configureEach( new Action<JavaCompile>() {
@Override
public void execute(JavaCompile compileTask) {
getJvmArgs( compileTask ).addAll(
Arrays.asList(
project.property( "toolchain.compiler.jvmargs" ).toString().split( " " )
)
);
compileTask.doFirst(
new Action<Task>() {
@Override
public void execute(Task task) {
project.getLogger().lifecycle(
"Compiling with '%s'",
compileTask.getJavaCompiler().get().getMetadata().getInstallationPath()
);
}
}
);
}
} );
project.getTasks().withType( Javadoc.class ).configureEach( (javadocTask) -> {
javadocTask.getOptions().setJFlags( javadocFlags( project ) );
javadocTask.doFirst( new Action<Task>() {
@Override
public void execute(Task task) {
project.getLogger().lifecycle(
"Generating javadoc with '%s'",
javadocTask.getJavadocTool().get().getMetadata().getInstallationPath()
);
}
} );
} );
}
}
private static List<String> javadocFlags(Project project) {
final String jvmArgs = project.property( "toolchain.javadoc.jvmargs" ).toString();
final String[] splits = jvmArgs.split( " " );
return Arrays.asList( splits ).stream().filter( (split) -> !split.isEmpty() ).collect( Collectors.toList() );
}
private void prepareCompileTask(JavaCompile compileTask, JavaLanguageVersion version) {
compileTask.getJavaCompiler().set(
toolchainService.compilerFor( new Action<JavaToolchainSpec>() {
@Override
public void execute(JavaToolchainSpec javaToolchainSpec) {
javaToolchainSpec.getLanguageVersion().set( version );
}
} )
);
compileTask.getOptions().getRelease().set( version.asInt() );
// Needs add-opens because of https://github.com/gradle/gradle/issues/15538
getJvmArgs( compileTask ).addAll( asList( "--add-opens", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" ) );
}
public static List<String> getJvmArgs(JavaCompile compileTask) {
final List<String> existing = compileTask
.getOptions()
.getForkOptions()
.getJvmArgs();
if ( existing == null ) {
final List<String> target = new ArrayList<>();
compileTask.getOptions().getForkOptions().setJvmArgs( target );
return target;
}
else {
return existing;
}
}
}

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

@ -0,0 +1,286 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html.
*/
package org.hibernate.orm.toolchains;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import org.gradle.StartParameter;
import org.gradle.api.Project;
import org.gradle.api.artifacts.VersionCatalog;
import org.gradle.api.artifacts.VersionConstraint;
import org.gradle.api.initialization.Settings;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.jetbrains.annotations.NotNull;
import static java.util.Objects.requireNonNullElse;
/**
* Describes the JDK versions of interest to the Hibernate build
*
* @author Steve Ebersole
*/
public class JdkVersionConfig {
public static final String DSL_NAME = "jdkVersions";
public static final String MAIN_JDK_VERSION = "main.jdk.version";
public static final String TEST_JDK_VERSION = "test.jdk.version";
private final boolean explicit;
private final JavaLanguageVersion baseline;
private final MainJdks main;
private final TestJdks test;
public JdkVersionConfig(
boolean explicit,
JavaLanguageVersion baseline,
JavaLanguageVersion mainCompileVersion,
JavaLanguageVersion mainReleaseVersion,
JavaLanguageVersion testCompileVersion,
JavaLanguageVersion testReleaseVersion,
JavaLanguageVersion testLauncherVersion) {
this.explicit = explicit;
this.baseline = baseline;
this.main = new MainJdks( mainCompileVersion, mainReleaseVersion );
this.test = new TestJdks( testCompileVersion, testReleaseVersion, testLauncherVersion );
}
public boolean isExplicitlyConfigured() {
return explicit;
}
public boolean isExplicit() {
return explicit;
}
public JavaLanguageVersion getBaselineVersion() {
return baseline;
}
public JavaLanguageVersion getBaseline() {
return baseline;
}
public MainJdks getMain() {
return main;
}
public TestJdks getTest() {
return test;
}
public JavaLanguageVersion getMainCompileVersion() {
return main.getCompile();
}
public JavaLanguageVersion getMainReleaseVersion() {
return main.getRelease();
}
public JavaLanguageVersion getTestCompileVersion() {
return test.getCompile();
}
public JavaLanguageVersion getTestReleaseVersion() {
return test.getRelease();
}
public JavaLanguageVersion getTestLauncherVersion() {
return test.getLauncher();
}
public Set<JavaLanguageVersion> getAllVersions() {
final HashSet<JavaLanguageVersion> versions = new HashSet<>();
versions.add( getMainCompileVersion() );
versions.add( getMainReleaseVersion() );
versions.add( getTestCompileVersion() );
versions.add( getTestReleaseVersion() );
versions.add( getTestLauncherVersion() );
return versions;
}
@NotNull
public static JdkVersionConfig createVersionConfig(
JavaLanguageVersion explicitMainVersion,
JavaLanguageVersion explicitTestVersion,
JavaLanguageVersion gradleJdkVersion,
JavaLanguageVersion baselineJdkVersion,
JavaLanguageVersion maxSupportedJdkVersion) {
final boolean explicitlyConfigured = explicitMainVersion != null || explicitTestVersion != null;
final JavaLanguageVersion mainCompileVersion;
final JavaLanguageVersion mainReleaseVersion;
final JavaLanguageVersion testCompileVersion;
final JavaLanguageVersion testReleaseVersion;
final JavaLanguageVersion testLauncherVersion;
if ( explicitlyConfigured ) {
mainCompileVersion = requireNonNullElse( explicitMainVersion, baselineJdkVersion );
testCompileVersion = requireNonNullElse( explicitTestVersion, baselineJdkVersion );
mainReleaseVersion = baselineJdkVersion;
if ( testCompileVersion.asInt() > gradleJdkVersion.asInt() ) {
System.out.println(
"[WARN] Gradle does not support bytecode version '${testCompilerVersion}'."
+ " Forcing test bytecode to version ${GRADLE_MAX_SUPPORTED_BYTECODE_VERSION}."
);
testReleaseVersion = maxSupportedJdkVersion;
}
else {
testReleaseVersion = testCompileVersion;
}
testLauncherVersion = testCompileVersion;
return new JdkVersionConfig(
false,
baselineJdkVersion,
mainCompileVersion,
mainReleaseVersion,
testCompileVersion,
testReleaseVersion,
testLauncherVersion
);
}
else {
// Not testing a particular JDK version: we will use the same JDK used to run Gradle.
// We disable toolchains for convenience, so that anyone can just run the build with their own JDK
// without any additional options and without downloading the whole JDK.
if ( gradleJdkVersion.asInt() > maxSupportedJdkVersion.asInt() ) {
System.out.println(
"[WARN] Gradle does not support this JDK, because it is too recent; build is likely to fail."
+ " To avoid failures, you should use an older Java version when running Gradle, and rely on toolchains."
+ " To that end, specify the version of Java you want to run tests with using property 'test.jdk.version',"
+ " and specify the path to JDK8 *and* a JDK of the test version using property 'org.gradle.java.installations.paths'."
+ " Example:"
+ " ./gradlew build -Ptest.jdk.version=15 -Porg.gradle.java.installations.paths=$SDKMAN_CANDIDATES_DIR/java/15.0.1-open,$SDKMAN_CANDIDATES_DIR/java/8"
);
}
return new JdkVersionConfig(
false,
baselineJdkVersion,
gradleJdkVersion,
baselineJdkVersion,
gradleJdkVersion,
baselineJdkVersion,
gradleJdkVersion
);
}
}
@NotNull
private static JavaLanguageVersion getJavaLanguageVersion(VersionCatalog jdks, String entryName) {
final VersionConstraint versionConstraint = jdks.findVersion( entryName ).orElseThrow();
return JavaLanguageVersion.of( versionConstraint.getRequiredVersion() );
}
public static JavaLanguageVersion extractVersion(Settings settings, String propertyName) {
final StartParameter startParameters = settings.getGradle().getStartParameter();
final String projectProp = startParameters.getProjectProperties().get( propertyName );
if ( projectProp != null ) {
return JavaLanguageVersion.of( projectProp );
}
final String sysProp = startParameters.getSystemPropertiesArgs().get( propertyName );
if ( sysProp != null ) {
return JavaLanguageVersion.of( sysProp );
}
return null;
}
public static JavaLanguageVersion extractVersion(Project project, String propertyName) {
final Object projectProp = project.getProperties().get( propertyName );
if ( projectProp != null ) {
return JavaLanguageVersion.of( projectProp.toString() );
}
final Object sysProp = System.getProperties().get( propertyName );
if ( sysProp != null ) {
return JavaLanguageVersion.of( sysProp.toString() );
}
return null;
}
public static class MainJdks implements JdkVersionCombo {
private final JavaLanguageVersion compileVersion;
private final JavaLanguageVersion releaseVersion;
public MainJdks(JavaLanguageVersion compileVersion, JavaLanguageVersion releaseVersion) {
this.compileVersion = compileVersion;
this.releaseVersion = releaseVersion;
}
@Override
public JavaLanguageVersion getCompile() {
return compileVersion;
}
public JavaLanguageVersion getCompiler() {
return compileVersion;
}
@Override
public JavaLanguageVersion getRelease() {
return releaseVersion;
}
@Override
public String toString() {
return "[compile: " + compileVersion + ", release:" + releaseVersion + "]";
}
}
public static class TestJdks implements JdkVersionCombo {
private final JavaLanguageVersion compileVersion;
private final JavaLanguageVersion releaseVersion;
private final JavaLanguageVersion launcherVersion;
public TestJdks(
JavaLanguageVersion compileVersion,
JavaLanguageVersion releaseVersion,
JavaLanguageVersion launcherVersion) {
this.compileVersion = compileVersion;
this.releaseVersion = releaseVersion;
this.launcherVersion = launcherVersion;
}
public JavaLanguageVersion getCompiler() {
return compileVersion;
}
@Override
public JavaLanguageVersion getCompile() {
return compileVersion;
}
@Override
public JavaLanguageVersion getRelease() {
return releaseVersion;
}
public JavaLanguageVersion getLauncher() {
return launcherVersion;
}
@Override
public String toString() {
return "[compile: " + compileVersion + ", release:" + releaseVersion + ", launcher: " + launcherVersion + "]";
}
}
public interface JdkVersionCombo {
JavaLanguageVersion getCompile();
JavaLanguageVersion getRelease();
}
}

72
local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionPlugin.java Normal file
View File

@ -0,0 +1,72 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html.
*/
package org.hibernate.orm.toolchains;
import javax.inject.Inject;
import org.gradle.api.Action;
import org.gradle.api.JavaVersion;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.artifacts.VersionCatalog;
import org.gradle.api.artifacts.VersionCatalogsExtension;
import org.gradle.api.artifacts.VersionConstraint;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.gradle.jvm.toolchain.JavaToolchainService;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import org.jetbrains.annotations.NotNull;
import static org.hibernate.orm.toolchains.JdkVersionConfig.MAIN_JDK_VERSION;
import static org.hibernate.orm.toolchains.JdkVersionConfig.TEST_JDK_VERSION;
import static org.hibernate.orm.toolchains.JdkVersionConfig.createVersionConfig;
import static org.hibernate.orm.toolchains.JdkVersionConfig.extractVersion;
/**
* @author Steve Ebersole
*/
public class JdkVersionPlugin implements Plugin<Project> {
private final JavaToolchainService toolchainService;
@Inject
public JdkVersionPlugin(JavaToolchainService toolchainService) {
this.toolchainService = toolchainService;
}
@Override
public void apply(Project project) {
final JavaLanguageVersion explicitMainVersion = extractVersion( project, MAIN_JDK_VERSION );
final JavaLanguageVersion explicitTestVersion = extractVersion( project, TEST_JDK_VERSION );
final JavaLanguageVersion gradleJdkVersion = JavaLanguageVersion.of( JavaVersion.current().getMajorVersion() );
final VersionCatalogsExtension versionCatalogs = project.getExtensions().getByType( VersionCatalogsExtension.class );
final VersionCatalog jdkVersions = versionCatalogs.named( "jdks" );
final JavaLanguageVersion baselineJdkVersion = getJavaLanguageVersion( jdkVersions, "baseline" );
final JavaLanguageVersion maxSupportedJdkVersion = getJavaLanguageVersion( jdkVersions, "maxSupportedBytecode" );
final JdkVersionConfig jdkVersionConfig = createVersionConfig(
explicitMainVersion,
explicitTestVersion,
gradleJdkVersion,
baselineJdkVersion,
maxSupportedJdkVersion
);
project.getExtensions().add( JdkVersionConfig.DSL_NAME, jdkVersionConfig );
JdkVersionsLogging.logVersions( jdkVersionConfig );
}
@NotNull
private static JavaLanguageVersion getJavaLanguageVersion(VersionCatalog jdks, String entryName) {
final VersionConstraint versionConstraint = jdks.findVersion( entryName ).orElseThrow();
return JavaLanguageVersion.of( versionConstraint.getRequiredVersion() );
}
}

60
local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionSettingsPlugin.java Normal file
View File

@ -0,0 +1,60 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html.
*/
package org.hibernate.orm.toolchains;
import org.gradle.api.JavaVersion;
import org.gradle.api.Plugin;
import org.gradle.api.artifacts.VersionCatalog;
import org.gradle.api.artifacts.VersionConstraint;
import org.gradle.api.initialization.Settings;
import org.gradle.api.plugins.ExtraPropertiesExtension;
import org.gradle.jvm.toolchain.JavaLanguageVersion;
import org.jetbrains.annotations.NotNull;
import static org.hibernate.orm.toolchains.JdkVersionConfig.MAIN_JDK_VERSION;
import static org.hibernate.orm.toolchains.JdkVersionConfig.TEST_JDK_VERSION;
import static org.hibernate.orm.toolchains.JdkVersionConfig.createVersionConfig;
import static org.hibernate.orm.toolchains.JdkVersionConfig.extractVersion;
/**
* @author Steve Ebersole
*/
public class JdkVersionSettingsPlugin implements Plugin<Settings> {
@Override
public void apply(Settings settings) {
final JavaLanguageVersion explicitMainVersion = extractVersion( settings, MAIN_JDK_VERSION );
final JavaLanguageVersion explicitTestVersion = extractVersion( settings, TEST_JDK_VERSION );
final JavaLanguageVersion gradleJdkVersion = JavaLanguageVersion.of( JavaVersion.current().getMajorVersion() );
final JavaLanguageVersion baselineJdkVersion;
final JavaLanguageVersion maxSupportedJdkVersion;
// final VersionCatalogsExtension versionCatalogs = settings.getExtensions().getByType( VersionCatalogsExtension.class );
// final VersionCatalog jdkVersions = versionCatalogs.named( "jdks" );
// baselineJdkVersion = getJavaLanguageVersion( jdkVersions, "baseline" );
// maxSupportedJdkVersion = getJavaLanguageVersion( jdkVersions, "maxSupportedBytecode" );
baselineJdkVersion = JavaLanguageVersion.of( "11" );
maxSupportedJdkVersion = JavaLanguageVersion.of( "17" );
final JdkVersionConfig jdkVersionConfig = createVersionConfig(
explicitMainVersion,
explicitTestVersion,
gradleJdkVersion,
baselineJdkVersion,
maxSupportedJdkVersion
);
settings.getGradle().getExtensions().add( JdkVersionConfig.DSL_NAME, jdkVersionConfig );
JdkVersionsLogging.logVersions( jdkVersionConfig );
}
@NotNull
private static JavaLanguageVersion getJavaLanguageVersion(VersionCatalog jdks, String entryName) {
final VersionConstraint versionConstraint = jdks.findVersion( entryName ).orElseThrow();
return JavaLanguageVersion.of( versionConstraint.getRequiredVersion() );
}
}

43
local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionsLogging.java Normal file
View File

@ -0,0 +1,43 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html.
*/
package org.hibernate.orm.toolchains;
/**
* @author Steve Ebersole
*/
public class JdkVersionsLogging {
private static boolean logged = false;
public static void logVersions(JdkVersionConfig jdkVersionConfig) {
if ( logged ) {
return;
}
logged = true;
final String implicitExplicitString = jdkVersionConfig.isExplicit() ? "explicit" : "implicit";
System.out.println(
"Java versions for main code: " + jdkVersionConfig.getMain()
+ " (" + implicitExplicitString + ")"
);
System.out.println(
"Java versions for test code: " + jdkVersionConfig.getTest()
+ " (" + implicitExplicitString + ")"
);
}
public static void logOnce(String message) {
if ( logged ) {
return;
}
logged = true;
System.out.println( message );
}
}

5
release/release.gradle
View File

@ -12,6 +12,7 @@ import groovy.json.JsonSlurper
apply from: rootProject.file( 'gradle/module.gradle' )
apply plugin: 'org.hibernate.orm.build.doc-pub'
apply plugin: 'org.hibernate.orm.build.jdks'
apply plugin: 'idea'
idea.module {
@ -193,13 +194,13 @@ task aggregateJavadocs(type: Javadoc) {
options.addStringOption( 'Xdoclint:none', '-quiet' )
if ( gradle.ext.javaToolchainEnabled ) {
if ( jdkVersions.explicit ) {
options.setJFlags( getProperty( 'toolchain.javadoc.jvmargs' ).toString().
split( ' ' ).toList().findAll( { !it.isEmpty() } ) )
}
}
if ( gradle.ext.javaToolchainEnabled ) {
if ( jdkVersions.explicit ) {
// Display version of Java tools
doFirst {
if ( javadocTool.present ) {

80
settings.gradle
View File

@ -51,6 +51,13 @@ dependencyResolutionManagement {
}
versionCatalogs {
jdks {
version( "baseline", "11" )
// Gradle does bytecode transformation on tests.
// You can't use bytecode higher than what Gradle supports, even with toolchains.
version( "maxSupportedBytecode", "21" )
}
libs {
def antlrVersion = "4.10.1"
def byteBuddyVersion = "1.14.5"
@ -278,79 +285,6 @@ buildCache {
}
}
gradle.ext.baselineJavaVersion = JavaLanguageVersion.of( 11 )
// Gradle does bytecode transformation on tests.
// You can't use bytecode higher than what Gradle supports, even with toolchains.
def GRADLE_MAX_SUPPORTED_BYTECODE_VERSION = 21
// If either 'main.jdk.version' or 'test.jdk.version' is set, enable the toolchain and use the selected jdk.
// If only one property is set, the other defaults to the baseline Java version (11).
// Note that when toolchain is enabled, you also need to specify
// the location of the selected jdks
// (auto-download and auto-detect are disabled in gradle.properties).
//
// Example (with SDKMAN):
// ./gradlew build -Ptest.jdk.version=15 \
// -Porg.gradle.java.installations.paths=$SDKMAN_CANDIDATES_DIR/java/15.0.1-open,$SDKMAN_CANDIDATES_DIR/java/8
if ( hasProperty( 'main.jdk.version' ) || hasProperty( 'test.jdk.version' ) ) {
// Testing a particular JDK version
// Gradle doesn't support all JDK versions unless we use toolchains
gradle.ext.javaToolchainEnabled = true
gradle.ext.javaVersions = [
main: [
compiler: JavaLanguageVersion.of( hasProperty( 'main.jdk.version' )
? getProperty( 'main.jdk.version' ) : gradle.ext.baselineJavaVersion.asInt() ),
release: gradle.ext.baselineJavaVersion
],
test: [
compiler: JavaLanguageVersion.of( hasProperty( 'test.jdk.version' )
? getProperty( 'test.jdk.version' ) : gradle.ext.baselineJavaVersion.asInt() )
]
]
def testCompilerVersion = gradle.ext.javaVersions.test.compiler
if ( testCompilerVersion.asInt() > GRADLE_MAX_SUPPORTED_BYTECODE_VERSION ) {
logger.warn( "[WARN] Gradle does not support bytecode version '${testCompilerVersion}'." +
" Forcing test bytecode to version ${GRADLE_MAX_SUPPORTED_BYTECODE_VERSION}." )
gradle.ext.javaVersions.test.release = JavaLanguageVersion.of( GRADLE_MAX_SUPPORTED_BYTECODE_VERSION )
}
else {
gradle.ext.javaVersions.test.release = testCompilerVersion
}
gradle.ext.javaVersions.test.launcher = testCompilerVersion
}
else {
// Not testing a particular JDK version: we will use the same JDK used to run Gradle.
// We disable toolchains for convenience, so that anyone can just run the build with their own JDK
// without any additional options and without downloading the whole JDK.
gradle.ext.javaToolchainEnabled = false
def gradleJdkVersion = JavaLanguageVersion.of( JavaVersion.current().getMajorVersion() )
if ( gradleJdkVersion.asInt() > GRADLE_MAX_SUPPORTED_BYTECODE_VERSION ) {
logger.warn( "[WARN] Gradle does not support this JDK, because it is too recent; build is likely to fail." +
" To avoid failures, you should use an older Java version when running Gradle, and rely on toolchains." +
" To that end, specify the version of Java you want to run tests with using property 'test.jdk.version'," +
" and specify the path to JDK8 *and* a JDK of the test version using property 'org.gradle.java.installations.paths'." +
" Example:" +
"./gradlew build -Ptest.jdk.version=15 -Porg.gradle.java.installations.paths=\$SDKMAN_CANDIDATES_DIR/java/15.0.1-open,\$SDKMAN_CANDIDATES_DIR/java/8" )
}
gradle.ext.javaVersions = [
main: [
compiler: gradleJdkVersion,
release: gradle.ext.baselineJavaVersion
],
test: [
compiler: gradleJdkVersion,
release: JavaLanguageVersion.of(
Math.min( GRADLE_MAX_SUPPORTED_BYTECODE_VERSION, gradleJdkVersion.asInt() ) ),
launcher: gradleJdkVersion
]
]
}
logger.lifecycle "Java versions for main code: " + gradle.ext.javaVersions.main
logger.lifecycle "Java versions for tests: " + gradle.ext.javaVersions.test
include 'hibernate-core'
include 'hibernate-testing'

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

@ -15,6 +15,8 @@ plugins {
// for local publishing
id 'maven-publish'
id 'org.hibernate.orm.build.jdks'
}
apply from: rootProject.file( 'gradle/module.gradle' )
@ -125,10 +127,10 @@ tasks.withType( JavaCompile ) {
options.encoding = 'UTF-8'
}
if ( !gradle.ext.javaToolchainEnabled ) {
if ( !jdkVersions.explicit ) {
tasks.withType( GroovyCompile ) {
sourceCompatibility = JavaVersion.toVersion( gradle.ext.baselineJavaVersion )
targetCompatibility = JavaVersion.toVersion( gradle.ext.baselineJavaVersion )
sourceCompatibility = JavaVersion.toVersion( gradle.jdkVersions.baseline )
targetCompatibility = JavaVersion.toVersion( gradle.jdkVersions.baseline )
}
}
else {

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

@ -48,12 +48,12 @@ compileTestJava {
// Tests with records
if ( gradle.ext.javaVersions.test.release.asInt() >= 17 && gradle.ext.javaToolchainEnabled ) {
if ( jdkVersions.test.release.asInt() >= 17 && jdkVersions.explicit ) {
// We need to configure the source and target version to 17
//compileTestJava17Java {
compileTestJava {
javaCompiler = javaToolchains.compilerFor {
languageVersion = gradle.ext.javaVersions.test.compiler
languageVersion = gradle.jdkVersions.test.compile
}
sourceCompatibility = 17
targetCompatibility = 17