hibernate-orm/release/release.gradle

743 lines
24 KiB
Groovy

import java.nio.charset.StandardCharsets
import java.util.function.Function
import groovy.json.JsonSlurper
/*
* 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>.
*/
apply from: rootProject.file( 'gradle/module.gradle' )
apply plugin: 'org.hibernate.orm.build.doc-pub'
apply plugin: 'idea'
idea.module {
}
configurations {
core
testing
envers
spatial
agroal
c3p0
hikaricp
proxool
vibur
jcache
jpamodelgen
javadocClasspath {
description = 'Class files for the javadoc to be built'
resolutionStrategy.capabilitiesResolution.withCapability('org.junit.jupiter:junit-jupiter-params:5.7.1') { details ->
details.select( details.candidates.first() ).because( 'first' )
}
extendsFrom core
extendsFrom testing
extendsFrom envers
extendsFrom spatial
extendsFrom agroal
extendsFrom c3p0
extendsFrom hikaricp
extendsFrom proxool
extendsFrom vibur
extendsFrom jcache
extendsFrom jpamodelgen
}
javadocSources {
description = 'Source files to be built by the javadoc tool'
}
}
// skip building this when `build` task is run from root, as many of our CI jobs do
tasks.build.dependsOn.clear()
dependencies {
attributesSchema { schema ->
schema.attribute(Bundling.BUNDLING_ATTRIBUTE) { matchStrategy ->
final def nameComparator = Comparator.comparing(
new Function<Bundling,String>() {
@Override
String apply(Bundling o) {
return o.name
}
}
)
matchStrategy.ordered(new Comparator<Bundling>() {
@Override
int compare(Bundling o1, Bundling o2) {
if ( Objects.equals( o1, o2 ) ) {
return 0;
}
if ( o1 == null ) {
return 1;
}
if ( o2 == null ) {
return -1;
}
if ( o1.name == Bundling.EMBEDDED ) {
return -1;
}
if ( o2.name == Bundling.EMBEDDED ) {
return 1;
}
return nameComparator.compare(o1,o2)
}
} )
}
}
core project( ':hibernate-core' )
javadocSources project( path: ':hibernate-core', configuration: 'javadocSources' )
testing project( ':hibernate-testing' )
javadocSources project( path: ':hibernate-testing', configuration: 'javadocSources' )
envers project( ':hibernate-envers' )
javadocSources project( path: ':hibernate-envers', configuration: 'javadocSources' )
spatial project( ':hibernate-spatial' )
javadocSources project( path: ':hibernate-spatial', configuration: 'javadocSources' )
agroal project( ':hibernate-agroal' )
javadocSources project( path: ':hibernate-agroal', configuration: 'javadocSources' )
c3p0 project( ':hibernate-c3p0' )
javadocSources project( path: ':hibernate-c3p0', configuration: 'javadocSources' )
hikaricp project( ':hibernate-hikaricp' )
javadocSources project( path: ':hibernate-hikaricp', configuration: 'javadocSources' )
proxool project( ':hibernate-proxool' )
javadocSources project( path: ':hibernate-proxool', configuration: 'javadocSources' )
vibur project( ':hibernate-vibur' )
javadocSources project( path: ':hibernate-vibur', configuration: 'javadocSources' )
jcache project( ':hibernate-jcache' )
javadocSources project( path: ':hibernate-jcache', configuration: 'javadocSources' )
jpamodelgen project( ':hibernate-jpamodelgen' )
javadocSources project( path: ':hibernate-jpamodelgen', configuration: 'javadocSources' )
javadocClasspath libs.loggingAnnotations
javadocClasspath jakartaLibs.validation
javadocClasspath jakartaLibs.cdi
javadocClasspath jakartaLibs.jacc
javadocClasspath jakartaLibs.jsonbApi
javadocClasspath libs.ant
javadocClasspath dbLibs.postgresql
javadocClasspath libs.jackson
javadocClasspath gradleApi()
javadocClasspath libs.jacksonXml
javadocClasspath dbLibs.oracle
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// aggregated JavaDoc
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
final File javadocDir = mkdir( new File( (File) project.buildDir, 'documentation/javadocs' ) );
/**
* Builds the JavaDocs aggregated (unified) across all the sub-projects
*/
task aggregateJavadocs(type: Javadoc) {
description = 'Builds an aggregated JavaDoc across all ORM sub-projects'
final int currentYear = new GregorianCalendar().get( Calendar.YEAR )
source configurations.javadocSources
classpath += configurations.javadocClasspath
// exclude any generated sources and internal packages
exclude '**/generated-src/**'
exclude '**/internal/**'
include '**/*.java'
// apply standard config
maxMemory = '512m'
destinationDir = javadocDir
configure( options ) {
overview = 'src/release/javadoc/overview.html'
stylesheetFile = new File(projectDir, 'src/release/javadoc/stylesheet.css')
windowTitle = 'Hibernate JavaDocs'
docTitle = "Hibernate JavaDoc ($project.version)"
bottom = "Copyright &copy; 2001-$currentYear <a href=\"https://redhat.com\">Red Hat, Inc.</a> All Rights Reserved."
use = true
options.encoding = 'UTF-8'
links = [
'https://docs.oracle.com/en/java/javase/11/docs/api/',
'https://docs.jboss.org/hibernate/beanvalidation/spec/2.0/api/',
'https://docs.jboss.org/cdi/api/2.0/',
'https://jakarta.ee/specifications/platform/8/apidocs/'
]
options.addStringOption( 'Xdoclint:none', '-quiet' )
if ( gradle.ext.javaToolchainEnabled ) {
options.setJFlags( getProperty( 'toolchain.javadoc.jvmargs' ).toString().
split( ' ' ).toList().findAll( { !it.isEmpty() } ) )
}
}
if ( gradle.ext.javaToolchainEnabled ) {
// Display version of Java tools
doFirst {
if ( javadocTool.present ) {
logger.lifecycle "Aggregating javadoc with '${javadocTool.get().metadata.installationPath}'"
}
}
}
}
task stageIntegrationGuide(type: Copy) {
group 'Release'
dependsOn ':documentation:renderIntegrationGuide'
from "${project( ':documentation' ).buildDir}/asciidoc/integrationguide"
into "${buildDir}/documentation/integrationguide"
}
task stageQuickstart(type: Copy) {
group 'Release'
dependsOn ':documentation:renderGettingStartedGuides'
from "${project( ':documentation' ).buildDir}/asciidoc/quickstart"
into "${buildDir}/documentation/quickstart"
}
task stageTopicalGuide(type: Copy) {
group 'Release'
dependsOn ':documentation:renderTopicalGuides'
from "${project( ':documentation' ).buildDir}/asciidoc/topical"
into "${buildDir}/documentation/topical"
}
task stageIntroduction(type: Copy) {
group 'Release'
dependsOn ':documentation:renderIntroduction', ':documentation:renderIntroductionPdf'
from "${project( ':documentation' ).buildDir}/asciidoc/introduction"
into "${buildDir}/documentation/introduction"
}
task stageQL(type: Copy) {
group 'Release'
dependsOn ':documentation:renderQL', ':documentation:renderQLPdf'
from "${project( ':documentation' ).buildDir}/asciidoc/querylanguage"
into "${buildDir}/documentation/querylanguage"
}
task stageUserGuide(type: Copy) {
group 'Release'
dependsOn ':documentation:renderUserGuide'
from "${project( ':documentation' ).buildDir}/asciidoc/userguide"
into "${buildDir}/documentation/userguide"
}
task stageMigrationGuide(type: Copy) {
group 'Release'
dependsOn ':documentation:renderMigrationGuide'
from project(":documentation").layout.buildDirectory.dir("asciidoc/migration-guide")
into layout.buildDirectory.dir("documentation/migration-guide")
}
tasks.named( "publishMigrationGuide" ).configure {
dependsOn stageMigrationGuide
migrationGuideDirectory = project.layout.buildDirectory.dir("documentation/migration-guide")
}
task stageOrmReports {
group 'Release'
dependsOn ':documentation:generateHibernateReports'
}
task stageOrmIncubationReport(type: Copy) { task ->
group 'Release'
dependsOn ':documentation:generateIncubationReport'
tasks.stageOrmReports.dependsOn task
from project( ":documentation" ).tasks.generateIncubationReport.reportFileReferenceAccess
into "${buildDir}/documentation/incubating"
}
task stageOrmInternalsReport(type: Copy) { task ->
group 'Release'
dependsOn ':documentation:generateInternalsReport'
tasks.stageOrmReports.dependsOn task
from project( ":documentation" ).tasks.generateInternalsReport.reportFileReferenceAccess
into "${buildDir}/documentation/internals"
}
task stageOrmDeprecationReport(type: Copy) { task ->
group 'Release'
dependsOn ':documentation:generateDeprecationReport'
tasks.stageOrmReports.dependsOn task
from project( ":documentation" ).tasks.generateDeprecationReport.reportFileReferenceAccess
into "${buildDir}/documentation/deprecated"
}
task stageOrmLoggingReport(type: Copy) { task ->
group 'Release'
dependsOn ':documentation:renderLoggingReport'
tasks.stageOrmReports.dependsOn task
from project( ":documentation" ).tasks.renderLoggingReport.outputDir
into "${buildDir}/documentation/logging"
}
task stageOrmDialectReport(type: Copy) { task ->
group 'Release'
dependsOn ':documentation:renderDialectReport'
tasks.stageOrmReports.dependsOn task
from project( ":documentation" ).tasks.renderDialectReport.outputDir
into "${buildDir}/documentation/dialect"
}
/**
* Assembles all documentation into the {buildDir}/documentation directory.
*
* Depends on building the docs
*/
task assembleDocumentation {
group 'Release'
description 'Assembles all documentation into the {buildDir}/documentation directory'
dependsOn ':documentation:buildDocsForPublishing'
dependsOn tasks.aggregateJavadocs
dependsOn tasks.stageIntegrationGuide
dependsOn tasks.stageTopicalGuide
dependsOn tasks.stageQuickstart
dependsOn tasks.stageIntroduction
dependsOn tasks.stageUserGuide
dependsOn tasks.stageMigrationGuide
dependsOn tasks.stageOrmReports
}
//task assembleProjectTemplates(type:Copy, dependsOn: project( ":project-template" ).tasks.assembleDist) {
// def templateProject = project( ":project-template" )
// from templateProject.layout.buildDirectory.dir( "distributions" )
// into projectTemplateStagingDir
//}
tasks.uploadDocumentation {
dependsOn assembleDocumentation
doFirst {
if ( rootProject.ormVersion.isSnapshot ) {
logger.error( "Cannot perform upload of SNAPSHOT documentation" );
throw new RuntimeException( "Cannot perform upload of SNAPSHOT documentation" );
}
else {
logger.lifecycle( "Uploading documentation ..." )
}
}
doLast {
logger.lifecycle( 'Done uploading documentation' )
}
}
task releaseChecks {
group 'Release'
description 'Checks and preparation for release'
}
task preVerifyRelease{
group 'Release'
description 'Pre-verifies a release job execution (Run locally before a CI release)'
dependsOn clean
dependsOn assembleDocumentation
}
task changeLogFile {
group 'Release'
description 'Updates the changelog.txt file based on the change-log report from Jira'
dependsOn project.tasks.releaseChecks
doFirst {
logger.lifecycle( "Appending version `${project.releaseVersion}` to changelog..." )
ChangeLogFile.update( ormVersion.fullName );
}
}
task changeToReleaseVersion {
group 'Release'
description 'Updates `gradle/version.properties` file to the specified release-version'
dependsOn project.tasks.releaseChecks
doFirst {
logger.lifecycle( "Updating version-file to release-version : `${project.releaseVersion}`" )
updateVersionFile( project.releaseVersion )
}
}
task gitPreparationForRelease {
dependsOn changeLogFile
dependsOn changeToReleaseVersion
doLast {
logger.lifecycle( "Performing pre-steps Git commit : `${project.releaseVersion}`" )
executeGitCommand( 'add', '.' )
executeGitCommand( 'commit', '-m', "Pre-steps for release : `${project.ormVersion.fullName}`" )
}
}
task changeToDevelopmentVersion {
group 'Release'
description 'Updates `gradle/version.properties` file to the specified development-version'
dependsOn project.tasks.releaseChecks
doFirst {
logger.lifecycle( "Updating version-file to development-version : `${project.developmentVersion}`" )
updateVersionFile( project.developmentVersion )
}
}
task gitTasksAfterRelease {
dependsOn changeToDevelopmentVersion
doLast {
logger.lifecycle( "Performing pre-steps Git commit : `${project.releaseVersion}`" )
executeGitCommand( 'add', '.' )
executeGitCommand( 'commit', '-m', "Post-steps for release : `${project.ormVersion.fullName}`" )
if ( project.createTag ) {
logger.lifecycle("Tagging release : `${project.releaseTag}`...")
executeGitCommand( 'tag', '-a', project.releaseTag, '-m', "Release $project.ormVersion.fullName" )
}
}
}
void updateVersionFile(String version) {
logger.lifecycle( "Updating `gradle/version.properties` version to `${version}`" )
project.ormVersionFile.text = "hibernateVersion=${version}"
}
task publishReleaseArtifacts {
dependsOn releaseChecks
dependsOn uploadDocumentation
mustRunAfter gitPreparationForRelease
}
task release {
group 'Release'
description 'Performs a release on local check-out, including updating changelog and '
dependsOn gitPreparationForRelease
dependsOn publishReleaseArtifacts
finalizedBy gitTasksAfterRelease
}
task ciReleaseChecks {
dependsOn releaseChecks
}
task gitTasksAfterCiRelease {
dependsOn gitTasksAfterRelease
doLast {
if ( project.createTag ) {
logger.lifecycle( "Pushing branch and tag to remote `${project.gitRemote}`..." )
executeGitCommand( 'push', '--atomic', project.gitRemote , project.gitBranch, project.releaseTag )
}
else {
logger.lifecycle("Pushing branch to remote `${project.gitRemote}`..." )
executeGitCommand( 'push', project.gitRemote , project.gitBranch )
}
}
}
task ciRelease {
group 'Release'
description 'Performs a release: the hibernate version is set and the changelog.txt file updated, the changes are pushed to github, then the release is performed, tagged and the hibernate version is set to the development one.'
dependsOn ciReleaseChecks
dependsOn release
finalizedBy gitTasksAfterCiRelease
}
static String executeGitCommand(Object ... subcommand){
List<Object> command = ['git']
Collections.addAll( command, subcommand )
def proc = command.execute()
def code = proc.waitFor()
def stdout = inputStreamToString( proc.getInputStream() )
def stderr = inputStreamToString( proc.getErrorStream() )
if ( code != 0 ) {
throw new GradleException( "An error occurred while executing " + command + "\n\nstdout:\n" + stdout + "\n\nstderr:\n" + stderr )
}
return stdout
}
static String inputStreamToString(InputStream inputStream) {
inputStream.withCloseable { ins ->
new BufferedInputStream(ins).withCloseable { bis ->
new ByteArrayOutputStream().withCloseable { buf ->
int result = bis.read();
while (result != -1) {
buf.write((byte) result);
result = bis.read();
}
return buf.toString( StandardCharsets.UTF_8.name());
}
}
}
}
class ChangeLogFile {
// Get the Release Notes from Jira and add them to the Hibernate changelog.txt file
static void update(String releaseVersion) {
def text = ""
File changelog = new File( "changelog.txt" )
def newReleaseNoteBlock = getNewReleaseNoteBlock(releaseVersion)
changelog.eachLine {
line ->
if ( line.startsWith( "Note:" ) ) {
text += line + System.lineSeparator() + System.lineSeparator() + newReleaseNoteBlock
}
else {
text += line + System.lineSeparator()
}
}
changelog.text = text
}
// Get the Release Notes from Jira
static String getNewReleaseNoteBlock(String releaseVersion) {
def restReleaseVersion;
if ( releaseVersion.endsWith( ".Final" ) ) {
restReleaseVersion = releaseVersion.replace( ".Final", "" )
}
else {
restReleaseVersion = releaseVersion
}
def apiString = "https://hibernate.atlassian.net/rest/api/2/search/?jql=project=HHH%20AND%20fixVersion=${restReleaseVersion}%20order%20by%20issuetype%20ASC"
def apiUrl = new URL( apiString )
def jsonReleaseNotes = new JsonSlurper().parse( apiUrl )
def releaseDate = new Date().format( 'MMMM dd, YYYY' )
def versionId = getVersionId( jsonReleaseNotes, restReleaseVersion )
ReleaseNote releaseNotes = new ReleaseNote( releaseVersion, releaseDate, versionId )
def issuetype
jsonReleaseNotes.issues.each {
issue ->
if ( issuetype != issue.fields.issuetype.name ) {
issuetype = issue.fields.issuetype.name
releaseNotes.addEmptyLine();
releaseNotes.addLine( "** ${issue.fields.issuetype.name}" )
}
releaseNotes.addLine( " * [" + issue.key + "] - " + issue.fields.summary )
}
releaseNotes.addEmptyLine()
return releaseNotes.notes
}
private static getVersionId(jsonReleaseNotes, String restReleaseVersion) {
def fixVersions = jsonReleaseNotes.issues.get( 0 ).fields.fixVersions
for ( def fixVersion : fixVersions ) {
if ( fixVersion.name.equals( restReleaseVersion ) ) {
return fixVersion.id
}
}
throw new GradleException( "Unable to determine the version id of the current release." )
}
}
class ReleaseNote {
String notes;
String notesHeaderSeparator = "------------------------------------------------------------------------------------------------------------------------"
ReleaseNote(String releaseVersion, String releaseDate, String versionId) {
notes = "Changes in ${releaseVersion} (${releaseDate})" + System.lineSeparator()
addHeaderSeparator()
addEmptyLine()
addLine( "https://hibernate.atlassian.net/projects/HHH/versions/${versionId}" )
}
void addLine(String text) {
notes += text + System.lineSeparator()
}
void addHeaderSeparator() {
addLine( notesHeaderSeparator )
}
void addEmptyLine() {
notes += System.lineSeparator()
}
void addEmptyLines(int numberOfLines) {
for ( i in 1..numberOfLines ) {
notes += System.lineSeparator()
}
}
}
gradle.getTaskGraph().whenReady {tg->
if ( tg.hasTask( project.tasks.releaseChecks )
&& ! project.getGradle().getStartParameter().isDryRun() ) {
String releaseVersionLocal
String developmentVersionLocal
def console = tg.hasTask( project.tasks.ciReleaseChecks )
? null
: System.console()
if (project.hasProperty('releaseVersion')) {
releaseVersionLocal = project.property('releaseVersion')
}
else {
if (console) {
// prompt for `releaseVersion`
releaseVersionLocal = console.readLine('> Enter the release version: ')
}
else {
throw new GradleException(
"`release`-related tasks require the following properties: 'releaseVersion', 'developmentVersion'"
)
}
}
if (project.hasProperty('developmentVersion')) {
developmentVersionLocal = project.property('developmentVersion')
}
else {
if (console) {
// prompt for `developmentVersion`
developmentVersionLocal = console.readLine('> Enter the next development version: ')
}
else {
throw new GradleException(
"`release`-related tasks require the following properties: 'releaseVersion', 'developmentVersion'"
)
}
}
assert releaseVersionLocal != null && developmentVersionLocal != null;
// set up information for the release-related tasks
project.ext {
releaseVersion = releaseVersionLocal;
developmentVersion = developmentVersionLocal;
createTag = !project.hasProperty('noTag')
releaseTag = project.createTag ? determineReleaseTag(releaseVersionLocal) : ''
}
logger.lifecycle("Checking that the working tree is clean...")
String uncommittedFiles = executeGitCommand('status', '--porcelain')
if (!uncommittedFiles.isEmpty()) {
throw new GradleException(
"Cannot release because there are uncommitted or untracked files in the working tree.\n" +
"Commit or stash your changes first.\n" +
"Uncommitted files:\n " +
uncommittedFiles
);
}
if (tg.hasTask(project.tasks.ciReleaseChecks)) {
String gitBranchLocal
String gitRemoteLocal
if (project.hasProperty('gitBranch')) {
gitBranchLocal = project.property('gitBranch')
}
else {
gitBranchLocal = executeGitCommand( 'branch', '--show-current' )
}
if (project.hasProperty('gitRemote')) {
gitRemoteLocal = project.property('gitRemote')
}
else {
final String remotes = executeGitCommand( 'remote', 'show' )
final List<String> tokens = remotes.tokenize()
if ( tokens.size() != 1 ) {
throw new GradleException( "Could not determine `gitRemote` property for `ciRelease` tasks." )
}
gitRemoteLocal = tokens.get( 0 )
}
project.ext {
gitBranch = gitBranchLocal
gitRemote = gitRemoteLocal
}
logger.lifecycle("Switching to branch '${project.gitBranch}'...")
executeGitCommand('checkout', project.gitBranch)
logger.lifecycle("Checking that all commits are pushed...")
String diffWithUpstream = executeGitCommand('diff', '@{u}')
if (!diffWithUpstream.isEmpty()) {
throw new GradleException(
"Cannot perform `ciRelease` tasks because there are un-pushed local commits .\n" +
"Push your commits first."
);
}
}
}
}
static String determineReleaseTag(String releaseVersion) {
return releaseVersion.endsWith( '.Final' )
? releaseVersion.replace( ".Final", "" )
: releaseVersion;
}