Use GitHub Actions

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,40 @@
+<!--
+For Security Vulnerabilities, please use https://spring.io/security-policy
+-->
+
+### Summary
+
+<!-- 
+Please provide a high level summary of the issue you are having
+-->
+
+### Actual Behavior
+
+<!-- 
+Please describe step by step the behavior you are observing
+-->
+
+### Expected Behavior
+
+<!--
+Please describe step by step the behavior you expect
+-->
+
+### Configuration
+
+<!--
+Please provide any configuration you have.
+-->
+
+### Version
+
+<!--
+Please describe what version you are using. Does the problem occur in other versions?
+-->
+
+### Sample
+
+<!--
+Providing a complete sample (i.e. link to a github repository) will give this issue higher
+priority than issues that do not have a complete sample
+-->

.github/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,24 @@
+---
+name: Bug
+about: Create a bug report to help us improve
+title: ''
+labels: 'status: waiting-for-triage, type: bug'
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Sample**
+
+A link to a GitHub repository with a [minimal, reproducible sample](https://stackoverflow.com/help/minimal-reproducible-example).
+
+Reports that include a sample will take priority over reports that do not.
+At times, we may require a sample, so it is good to try and include a sample up front.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Community Support
+    url: https://stackoverflow.com/questions/tagged/spring-security
+    about: Please ask and answer questions on StackOverflow with the tag `spring-security`.

.github/ISSUE_TEMPLATE/enhancement.md

@@ -0,0 +1,25 @@
+---
+name: Enhancement
+about: Suggest an enhancement for this project
+title: ''
+labels: 'status: waiting-for-triage, type: enhancement'
+assignees: ''
+
+---
+
+**Expected Behavior**
+
+<!--- Tell us how it should work -->
+
+**Current Behavior**
+
+<!--- Explain the difference from current behavior -->
+
+**Context**
+
+<!--- 
+How has this issue affected you?
+What are you trying to accomplish?
+What other alternatives have you considered?
+Are you aware of any workarounds?
+-->

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,9 @@
+<!--
+For Security Vulnerabilities, please use https://pivotal.io/security#reporting
+-->
+
+<!--
+Before creating new features, we recommend creating an issue to discuss the feature. This ensures that everyone is on the same page before extensive work is done.
+
+Thanks for contributing to Spring Session. Please provide a brief description of your pull-request and reference any related issue numbers (prefix references with gh-).
+-->

.github/workflows/clean_build_artifacts.yml

@@ -0,0 +1,17 @@
+name: Clean build artifacts
+on:
+  schedule:
+    - cron: '0 10 * * *' # Once per day at 10am UTC
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete artifacts in cron job
+        env:
+          GH_ACTIONS_REPO_TOKEN: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+        run: |
+          echo "Running clean build artifacts logic"
+          output=$(curl -X GET -H "Authorization: token $GH_ACTIONS_REPO_TOKEN" https://api.github.com/repos/spring-projects/spring-security/actions/artifacts | grep '"id"' | cut -d : -f2 | sed 's/,*$//g')
+          echo Output is $output
+          for id in $output; do curl -X DELETE -H "Authorization: token $GH_ACTIONS_REPO_TOKEN" https://api.github.com/repos/spring-projects/spring-security/actions/artifacts/$id; done;

.github/workflows/continuous-integration-workflow.yml

@@ -0,0 +1,72 @@
+name: CI
+
+on:
+  push:
+  schedule:
+    - cron: '0 10 * * *' # Once per day at 10am UTC
+  workflow_dispatch: # Manual trigger
+
+env:
+  SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+  GRADLE_ENTERPRISE_CACHE_USER: ${{ secrets.GRADLE_ENTERPRISE_CACHE_USER }}
+  GRADLE_ENTERPRISE_CACHE_PASSWORD: ${{ secrets.GRADLE_ENTERPRISE_CACHE_PASSWORD }}
+  GRADLE_ENTERPRISE_SECRET_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+  COMMIT_OWNER: ${{ github.event.pusher.name }}
+  COMMIT_SHA: ${{ github.sha }}
+  STRUCTURE101_LICENSEID: ${{ secrets.STRUCTURE101_LICENSEID }}
+  ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+  ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+  RUN_JOBS: ${{ github.repository == 'spring-projects/spring-session-bom' }}
+
+jobs:
+  prerequisites:
+    name: Pre-requisites for building
+    runs-on: ubuntu-latest
+    outputs:
+      runjobs: ${{ steps.continue.outputs.runjobs }}
+    steps:
+      - id: continue
+        name: Determine if should continue
+        if: env.RUN_JOBS == 'true'
+        run: echo "::set-output name=runjobs::true"
+  
+  deploy_artifacts:
+    name: Deploy Artifacts
+    needs: [prerequisites]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK
+        uses: actions/setup-java@v1
+        with:
+          java-version: '11'
+      - name: Setup gradle user name
+        run: |
+          mkdir -p ~/.gradle
+          echo 'systemProp.user.name=spring-builds+github' >> ~/.gradle/gradle.properties
+      - name: Deploy artifacts
+        run: |
+          export GRADLE_ENTERPRISE_CACHE_USERNAME="$GRADLE_ENTERPRISE_CACHE_USER"
+          export GRADLE_ENTERPRISE_CACHE_PASSWORD="$GRADLE_ENTERPRISE_CACHE_PASSWORD"
+          export GRADLE_ENTERPRISE_ACCESS_KEY="$GRADLE_ENTERPRISE_SECRET_ACCESS_KEY"
+          ./gradlew publishArtifacts finalizeDeployArtifacts -PossrhUsername="$OSSRH_TOKEN_USERNAME" -PossrhPassword="$OSSRH_TOKEN_PASSWORD" -PartifactoryUsername="$ARTIFACTORY_USERNAME" -PartifactoryPassword="$ARTIFACTORY_PASSWORD" --stacktrace
+        env:
+          ORG_GRADLE_PROJECT_signingKey: ${{ secrets.GPG_PRIVATE_KEY }}
+          ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.GPG_PASSPHRASE }}
+          OSSRH_TOKEN_USERNAME: ${{ secrets.OSSRH_S01_TOKEN_USERNAME }}
+          OSSRH_TOKEN_PASSWORD: ${{ secrets.OSSRH_S01_TOKEN_PASSWORD }}
+          ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+          ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+  notify_result:
+    name: Check for failures
+    needs: [deploy_artifacts]
+    if: failure()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send Slack message
+        uses: Gamesight/slack-workflow-status@v1.0.1
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          channel: '#spring-session-ci'
+          name: 'CI Notifier'

.github/workflows/pr-build-workflow.yml

@@ -0,0 +1,28 @@
+name: PR Build
+
+on: pull_request
+
+env:
+  RUN_JOBS: ${{ github.repository == 'spring-projects/spring-security' }}
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - if: env.RUN_JOBS == 'true'
+        uses: actions/checkout@v2
+      - name: Set up JDK
+        if: env.RUN_JOBS == 'true'
+        uses: actions/setup-java@v1
+        with:
+          java-version: '11'
+      - name: Cache Gradle packages
+        if: env.RUN_JOBS == 'true'
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+      - name: Build with Gradle
+        if: env.RUN_JOBS == 'true'
+        run: ./gradlew clean build --continue --scan

build.gradle

@@ -1,87 +1,19 @@
-buildscript {
-	dependencies {
-		classpath 'io.spring.gradle:spring-build-conventions:0.0.37'
-		classpath 'io.spring.nohttp:nohttp-gradle:0.0.9'
-	}
+plugins {
+	id 'io.spring.convention.bom'
+	id 'io.spring.convention.root'
+}
 
-	repositories {
-		gradlePluginPortal()
-		maven { url 'https://repo.spring.io/plugins-release/' }
+description = "Spring Session BOM"
+group = "org.springframework.session"
+
+
+dependencies {
+	constraints {
+		api "org.springframework.session:spring-session-core:$springSessionCoreVersion"
+		api "org.springframework.session:spring-session-data-geode:$springSessionDataGeodeVersion"
+		api "org.springframework.session:spring-session-data-mongodb:$springSessionCoreVersion"
+		api "org.springframework.session:spring-session-data-redis:$springSessionCoreVersion"
+		api "org.springframework.session:spring-session-hazelcast:$springSessionCoreVersion"
+		api "org.springframework.session:spring-session-jdbc:$springSessionCoreVersion"
 	}
 }
-
-apply plugin: 'io.spring.convention.root'
-apply plugin: 'io.spring.convention.springdependencymangement'
-apply plugin: 'io.spring.convention.maven'
-apply plugin: 'io.spring.convention.artifactory'
-
-group = 'org.springframework.session'
-description = 'Spring Session Maven Bill of Materials (BOM)'
-
-artifacts {
-	archives file('spring-session-bom.txt')
-}
-
-dependencyManagement {
-	generatedPomCustomization {
-		enabled = true
-	}
-}
-
-def installer = install.repositories.mavenInstaller
-def deployer = uploadArchives.repositories.mavenDeployer
-
-[installer, deployer]*.pom*.whenConfigured { pom ->
-	pom.project {
-		packaging = 'pom'
-		name = project.description
-		description = project.description
-		url = 'https://projects.spring.io/spring-session/'
-
-		organization {
-			name = 'Pivotal Software, Inc.'
-			url = 'https://spring.io/'
-		}
-
-		licenses {
-			license {
-				name = 'Apache License, Version 2.0'
-				url = 'https://www.apache.org/licenses/LICENSE-2.0'
-				distribution = 'repo'
-			}
-		}
-
-		developers {
-			developer {
-				id = 'rwinch'
-				name = 'Rob Winch'
-				email = 'rwinch@pivotal.io'
-			}
-		}
-
-		scm {
-			url = 'https://github.com/spring-projects/spring-session-bom'
-			connection = 'scm:git:git@github.com/spring-projects/spring-session-bom.git'
-			developerConnection = 'scm:git:git@github.com/spring-projects/spring-session-bom.git'
-		}
-
-		issueManagement {
-			system = 'GitHub'
-			url = 'https://github.com/spring-projects/spring-session/issues'
-		}
-	}
-}
-
-task deployArtifacts {
-	group = 'Deploy tasks'
-	description = 'Deploys the artifacts to either Artifactory or Maven Central'
-}
-
-if (version.matches(/.*\.[0-9]+$/)) {
-	deployArtifacts.dependsOn uploadArchives
-}
-else {
-	deployArtifacts.dependsOn artifactoryPublish
-}
-
-sonarqube.skipProject = true

buildSrc/build.gradle

@@ -0,0 +1,121 @@
+plugins {
+	id "java-gradle-plugin"
+	id "java"
+	id "groovy"
+	id 'com.apollographql.apollo' version '2.4.5'
+}
+
+sourceCompatibility = JavaVersion.VERSION_11
+
+repositories {
+	gradlePluginPortal()
+	mavenCentral()
+	maven { url 'https://repo.spring.io/plugins-release/' }
+}
+
+sourceSets {
+	main {
+		java {
+			srcDirs = []
+		}
+		groovy {
+			srcDirs += ["src/main/java"]
+		}
+	}
+}
+
+gradlePlugin {
+	plugins {
+		checkAntoraVersion {
+			id = "org.springframework.antora.check-version"
+			implementationClass = "org.springframework.gradle.antora.AntoraVersionPlugin"
+		}
+		trang {
+			id = "trang"
+			implementationClass = "trang.TrangPlugin"
+		}
+		locks {
+			id = "locks"
+			implementationClass = "lock.GlobalLockPlugin"
+		}
+		managementConfiguration {
+			id = "io.spring.convention.management-configuration"
+			implementationClass = "io.spring.gradle.convention.ManagementConfigurationPlugin"
+		}
+		updateDependencies {
+			id = "org.springframework.security.update-dependencies"
+			implementationClass = "org.springframework.security.convention.versions.UpdateDependenciesPlugin"
+		}
+		updateProjectVersion {
+			id = "org.springframework.security.update-version"
+			implementationClass = "org.springframework.security.convention.versions.UpdateProjectVersionPlugin"
+		}
+		sagan {
+			id = "org.springframework.security.sagan"
+			implementationClass = "org.springframework.gradle.sagan.SaganPlugin"
+		}
+		githubMilestone {
+			id = "org.springframework.github.milestone"
+			implementationClass = "org.springframework.gradle.github.milestones.GitHubMilestonePlugin"
+		}
+		githubChangelog {
+			id = "org.springframework.github.changelog"
+			implementationClass = "org.springframework.gradle.github.changelog.GitHubChangelogPlugin"
+		}
+		githubRelease {
+			id = "org.springframework.github.release"
+			implementationClass = "org.springframework.gradle.github.release.GitHubReleasePlugin"
+		}
+		s101 {
+			id = "s101"
+			implementationClass = "s101.S101Plugin"
+		}
+	}
+}
+
+configurations {
+	implementation {
+		exclude module: 'groovy-all'
+	}
+}
+
+dependencies {
+	implementation 'com.google.code.gson:gson:2.8.6'
+	implementation 'com.thaiopensource:trang:20091111'
+	implementation 'net.sourceforge.saxon:saxon:9.1.0.8'
+	implementation 'org.yaml:snakeyaml:1.30'
+	implementation localGroovy()
+
+	implementation 'io.github.gradle-nexus:publish-plugin:1.1.0'
+	implementation 'io.projectreactor:reactor-core:3.5.0-M2'
+	implementation 'gradle.plugin.org.gretty:gretty:3.0.1'
+	implementation 'com.apollographql.apollo:apollo-runtime:2.4.5'
+	implementation 'com.github.ben-manes:gradle-versions-plugin:0.38.0'
+	implementation 'com.github.spullara.mustache.java:compiler:0.9.4'
+	implementation 'io.spring.javaformat:spring-javaformat-gradle-plugin:0.0.15'
+	implementation 'io.spring.nohttp:nohttp-gradle:0.0.10'
+	implementation 'net.sourceforge.htmlunit:htmlunit:2.37.0'
+	implementation 'org.hidetake:gradle-ssh-plugin:2.10.1'
+	implementation 'org.jfrog.buildinfo:build-info-extractor-gradle:4.26.1'
+	implementation 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.7.1'
+
+	testImplementation platform('org.junit:junit-bom:5.9.0-M1')
+	testImplementation "org.junit.jupiter:junit-jupiter-api"
+	testImplementation "org.junit.jupiter:junit-jupiter-params"
+	testImplementation "org.junit.jupiter:junit-jupiter-engine"
+	testImplementation 'org.apache.commons:commons-io:1.3.2'
+	testImplementation 'org.assertj:assertj-core:3.13.2'
+	testImplementation 'org.mockito:mockito-core:3.12.4'
+	testImplementation 'org.mockito:mockito-junit-jupiter:3.12.4'
+	testImplementation "com.squareup.okhttp3:mockwebserver:3.14.9"
+}
+
+
+tasks.named('test', Test).configure {
+	onlyIf { !project.hasProperty("buildSrc.skipTests") }
+	useJUnitPlatform()
+	jvmArgs(
+			'--add-opens', 'java.base/java.lang=ALL-UNNAMED',
+			'--add-opens', 'java.base/java.util=ALL-UNNAMED'
+	)
+}

buildSrc/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

buildSrc/src/main/graphql/org/springframework/security/convention/versions/CreateIssue.graphql

@@ -0,0 +1,7 @@
+mutation CreateIssueInput($assigneeId: ID!, $labelIds: [ID!], $milestoneId: ID!, $repositoryId: ID!, $title: String!) {
+    createIssue(input: {assigneeIds: [$assigneeId], labelIds: $labelIds, milestoneId: $milestoneId, projectIds: [], repositoryId: $repositoryId, title: $title}) {
+        issue {
+            number
+        }
+    }
+}

buildSrc/src/main/graphql/org/springframework/security/convention/versions/FindCreateIssueInput.graphql

@@ -0,0 +1,20 @@
+query FindCreateIssueInput($owner: String!, $name: String!, $labelQuery: String, $milestoneName: String) {
+  repository(owner: $owner, name: $name) {
+      id
+      labels(query: $labelQuery, first: 1) {
+          nodes {
+              id
+              name
+          }
+      }
+      milestones(query: $milestoneName, states: [OPEN], first: 1) {
+          nodes {
+              id
+              title
+          }
+      }
+  }
+  viewer {
+      id
+  }
+}

buildSrc/src/main/graphql/org/springframework/security/convention/versions/RateLimit.graphql

@@ -0,0 +1,8 @@
+query RateLimit {
+    rateLimit {
+        limit
+        cost
+        remaining
+        resetAt
+    }
+}

buildSrc/src/main/groovy/io/spring/gradle/IncludeRepoTask.groovy

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+
+package io.spring.gradle
+
+import groovy.transform.CompileStatic
+import groovy.transform.TypeChecked
+import groovy.transform.TypeCheckingMode
+import org.gradle.api.DefaultTask
+import org.gradle.api.Task
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+
+/**
+ * Checkout a project template from a git repository.
+ *
+ * @author Marcus Da Coregio
+ */
+@CompileStatic
+abstract class IncludeRepoTask extends DefaultTask {
+
+	private static final String DEFAULT_URI_PREFIX = 'https://github.com/'
+
+	/**
+	 * Git repository to use. Will be prefixed with {@link #DEFAULT_URI_PREFIX} if it isn't already
+	 * @return
+	 */
+	@Input
+	abstract Property<String> getRepository();
+
+	/**
+	 * Git reference to use.
+	 */
+	@Input
+	abstract Property<String> getRef()
+
+	/**
+	 * Directory where the project template should be copied.
+	 */
+	@OutputDirectory
+	final File outputDirectory = project.file("$project.buildDir/$name")
+
+	@TaskAction
+	void checkoutAndCopy() {
+		outputDirectory.deleteDir()
+		File checkoutDir = checkout(this, getRemoteUri(), ref.get())
+		moveToOutputDir(checkoutDir, outputDirectory)
+	}
+
+	private static File cleanTemporaryDir(Task task, File tmpDir) {
+		if (tmpDir.exists()) {
+			task.project.delete(tmpDir)
+		}
+		return tmpDir
+	}
+
+	static File checkout(Task task, String remoteUri, String ref) {
+		checkout(task, remoteUri, ref, task.getTemporaryDir())
+	}
+
+	@TypeChecked(TypeCheckingMode.SKIP)
+	static File checkout(Task task, String remoteUri, String ref, File checkoutDir) {
+		cleanTemporaryDir(task, checkoutDir)
+		task.project.exec {
+			commandLine = ["git", "clone", "--no-checkout", remoteUri, checkoutDir.absolutePath]
+			errorOutput = System.err
+		}
+		task.project.exec {
+			commandLine = ["git", "checkout", ref]
+			workingDir = checkoutDir
+			errorOutput = System.err
+		}
+		return checkoutDir
+	}
+
+	private static void moveToOutputDir(File tmpDir, File outputDirectory) {
+		File baseDir = tmpDir
+		baseDir.renameTo(outputDirectory)
+	}
+
+	private String getRemoteUri() {
+		String remoteUri = this.repository.get()
+		if (remoteUri.startsWith(DEFAULT_URI_PREFIX)) {
+			return remoteUri
+		}
+		return DEFAULT_URI_PREFIX + remoteUri
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/AbstractSpringJavaPlugin.groovy

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.GroovyPlugin;
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.plugins.PluginManager;
+import org.gradle.plugins.ide.eclipse.EclipseWtpPlugin;
+import org.gradle.plugins.ide.idea.IdeaPlugin;
+import org.springframework.gradle.CopyPropertiesPlugin
+import org.springframework.gradle.propdeps.PropDepsEclipsePlugin
+import org.springframework.gradle.propdeps.PropDepsIdeaPlugin
+import org.springframework.gradle.propdeps.PropDepsPlugin;
+
+/**
+ * @author Rob Winch
+ */
+public abstract class AbstractSpringJavaPlugin implements Plugin<Project> {
+
+	@Override
+	public final void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(JavaPlugin.class);
+		pluginManager.apply(ManagementConfigurationPlugin.class)
+		if (project.file("src/main/groovy").exists()
+				|| project.file("src/test/groovy").exists()
+				|| project.file("src/integration-test/groovy").exists()) {
+			pluginManager.apply(GroovyPlugin.class);
+		}
+		pluginManager.apply("io.spring.convention.repository");
+		pluginManager.apply(EclipseWtpPlugin);
+		pluginManager.apply(IdeaPlugin);
+		pluginManager.apply(PropDepsPlugin);
+		pluginManager.apply(PropDepsEclipsePlugin);
+		pluginManager.apply(PropDepsIdeaPlugin);
+		pluginManager.apply("io.spring.convention.tests-configuration");
+		pluginManager.apply("io.spring.convention.integration-test");
+		pluginManager.apply("io.spring.convention.javadoc-options");
+		pluginManager.apply("io.spring.convention.checkstyle");
+		pluginManager.apply(CopyPropertiesPlugin);
+
+		project.jar {
+			manifest.attributes["Created-By"] =
+					"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
+			manifest.attributes["Implementation-Title"] = project.name
+			manifest.attributes["Implementation-Version"] = project.version
+			manifest.attributes["Automatic-Module-Name"] = project.name.replace('-', '.')
+		}
+        project.test {
+            useJUnitPlatform()
+        }
+		additionalPlugins(project);
+	}
+
+	protected abstract void additionalPlugins(Project project);
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/ArtifactoryPlugin.groovy

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package io.spring.gradle.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class ArtifactoryPlugin implements Plugin<Project> {
+
+	@Override
+	void apply(Project project) {
+		project.plugins.apply('com.jfrog.artifactory')
+		String name = Utils.getProjectName(project);
+		boolean isSnapshot = Utils.isSnapshot(project);
+		boolean isMilestone = Utils.isMilestone(project);
+		project.artifactory {
+			contextUrl = 'https://repo.spring.io'
+			publish {
+				repository {
+					repoKey = isSnapshot ? 'libs-snapshot-local' : isMilestone ? 'libs-milestone-local' : 'libs-release-local'
+					if(project.hasProperty('artifactoryUsername')) {
+						username = artifactoryUsername
+						password = artifactoryPassword
+					}
+				}
+				defaults {
+					publications('mavenJava')
+				}
+			}
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/CheckstylePlugin.groovy

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2016-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPlugin
+
+/**
+ * Adds and configures Checkstyle plugin.
+ *
+ * @author Vedran Pavic
+ */
+class CheckstylePlugin implements Plugin<Project> {
+
+	final CHECKSTYLE_DIR = 'etc/checkstyle'
+
+	@Override
+	void apply(Project project) {
+		project.plugins.withType(JavaPlugin) {
+			def checkstyleDir = project.rootProject.file(CHECKSTYLE_DIR)
+			if (checkstyleDir.exists() && checkstyleDir.directory) {
+				project.getPluginManager().apply('checkstyle')
+				project.dependencies.add('checkstyle', 'io.spring.javaformat:spring-javaformat-checkstyle:0.0.15')
+				project.dependencies.add('checkstyle', 'io.spring.nohttp:nohttp-checkstyle:0.0.10')
+
+				project.checkstyle {
+					configDirectory = checkstyleDir
+					toolVersion = '8.21'
+				}
+			}
+		}
+	}
+
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/DeployDocsPlugin.groovy

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package io.spring.gradle.convention
+
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+public class DeployDocsPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.getPluginManager().apply('org.hidetake.ssh')
+
+		project.ssh.settings {
+			knownHosts = allowAnyHosts
+		}
+		project.remotes {
+			docs {
+				role 'docs'
+				if (project.hasProperty('deployDocsHost')) {
+					host = project.findProperty('deployDocsHost')
+				} else {
+					host = 'docs.af.pivotal.io'
+				}
+				retryCount = 5 // retry 5 times (default is 0)
+				retryWaitSec = 10 // wait 10 seconds between retries (default is 0)
+				user = project.findProperty('deployDocsSshUsername')
+				if (project.hasProperty('deployDocsSshKeyPath')) {
+					identity = project.file(project.findProperty('deployDocsSshKeyPath'))
+				} else if (project.hasProperty('deployDocsSshKey')) {
+					identity = project.findProperty('deployDocsSshKey')
+				}
+				if(project.hasProperty('deployDocsSshPassphrase')) {
+					passphrase = project.findProperty('deployDocsSshPassphrase')
+				}
+			}
+		}
+
+		project.task('deployDocs') {
+			dependsOn 'docsZip'
+			doFirst {
+				project.ssh.run {
+					session(project.remotes.docs) {
+						def now = System.currentTimeMillis()
+						def name = project.rootProject.name
+						def version = project.rootProject.version
+						def tempPath = "/tmp/${name}-${now}-docs/".replaceAll(' ', '_')
+						execute "mkdir -p $tempPath"
+
+						project.tasks.docsZip.outputs.each { o ->
+							put from: o.files, into: tempPath
+						}
+
+						execute "unzip $tempPath*.zip -d $tempPath"
+
+						def extractPath = "/var/www/domains/spring.io/docs/htdocs/autorepo/docs/${name}/${version}/"
+
+						execute "rm -rf $extractPath"
+						execute "mkdir -p $extractPath"
+						execute "mv $tempPath/docs/* $extractPath"
+						execute "chmod -R g+w $extractPath"
+					}
+				}
+			}
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/DocsPlugin.groovy

@@ -0,0 +1,45 @@
+package io.spring.gradle.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.plugins.BasePlugin
+import org.gradle.api.plugins.PluginManager
+import org.gradle.api.tasks.bundling.Zip
+
+/**
+ * Aggregates asciidoc, javadoc, and deploying of the docs into a single plugin
+ */
+public class DocsPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(BasePlugin);
+		pluginManager.apply(DeployDocsPlugin);
+		pluginManager.apply(JavadocApiPlugin);
+
+		Task docsZip = project.tasks.create('docsZip', Zip) {
+			dependsOn 'api'
+			group = 'Distribution'
+			archiveBaseName = project.rootProject.name
+			archiveClassifier = 'docs'
+			description = "Builds -${archiveClassifier.get()} archive containing all " +
+				"Docs for deployment at docs.spring.io"
+
+			from(project.tasks.api.outputs) {
+				into 'api'
+			}
+			into 'docs'
+			duplicatesStrategy 'exclude'
+		}
+
+		Task docs = project.tasks.create("docs") {
+			group = 'Documentation'
+			description 'An aggregator task to generate all the documentation'
+			dependsOn docsZip
+		}
+		project.tasks.assemble.dependsOn docs
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/IncludeCheckRemotePlugin.groovy

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention
+
+import io.spring.gradle.IncludeRepoTask
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.tasks.GradleBuild
+import org.gradle.api.tasks.TaskProvider
+
+/**
+ * Adds a set of tasks that make easy to clone a remote repository and perform some task
+ *
+ * @author Marcus Da Coregio
+ */
+class IncludeCheckRemotePlugin implements Plugin<Project> {
+	@Override
+	void apply(Project project) {
+		IncludeCheckRemoteExtension extension = project.extensions.create('includeCheckRemote', IncludeCheckRemoteExtension)
+		TaskProvider<IncludeRepoTask> includeRepoTask = project.tasks.register('includeRepo', IncludeRepoTask) { IncludeRepoTask it ->
+			it.repository = extension.repository
+			it.ref = extension.ref
+		}
+		project.tasks.register('checkRemote', GradleBuild) {
+			it.dependsOn 'includeRepo'
+			it.dir = includeRepoTask.get().outputDirectory
+			it.tasks = extension.getTasks()
+			extension.getInitScripts().forEach {script ->
+				it.startParameter.addInitScript(new File(script))
+			}
+			extension.getProjectProperties().entrySet().forEach { entry ->
+				it.startParameter.projectProperties.put(entry.getKey(), entry.getValue())
+			}
+		}
+	}
+
+	abstract static class IncludeCheckRemoteExtension {
+
+		/**
+		 * Git repository to clone
+		 */
+		String repository;
+
+		/**
+		 * Git ref to checkout
+		 */
+		String ref
+
+		/**
+		 * Task to run in the repository
+		 */
+		List<String> tasks = ['check']
+
+		/**
+		 * Init scripts for the build
+		 */
+		List<String> initScripts = []
+
+		/**
+		 * Map of properties for the build
+		 */
+		Map<String, String> projectProperties = [:]
+
+	}
+
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/IntegrationTestPlugin.groovy

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2016-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package io.spring.gradle.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.plugins.GroovyPlugin
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.tasks.testing.Test
+import org.gradle.plugins.ide.eclipse.EclipsePlugin
+import org.gradle.plugins.ide.idea.IdeaPlugin
+import org.springframework.gradle.propdeps.PropDepsPlugin
+
+/**
+ *
+ * Adds support for integration tests to java projects.
+ *
+ * <ul>
+ * <li>Adds integrationTestCompile and integrationTestRuntime configurations</li>
+ * <li>A new source test folder of src/integration-test/java has been added</li>
+ * <li>A task to run integration tests named integrationTest is added</li>
+ * <li>If Groovy plugin is added a new source test folder src/integration-test/groovy is added</li>
+ * </ul>
+ *
+ * @author Rob Winch
+ */
+public class IntegrationTestPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.plugins.withType(JavaPlugin.class) {
+			applyJava(project)
+		}
+	}
+
+	private applyJava(Project project) {
+		if(!project.file('src/integration-test/').exists()) {
+			// ensure we don't add if no tests to avoid adding Gretty
+			return
+		}
+		project.configurations {
+			integrationTestCompile {
+				extendsFrom testImplementation
+			}
+			integrationTestRuntime {
+				extendsFrom integrationTestCompile, testRuntime, testRuntimeOnly
+			}
+			integrationTestCompileClasspath {
+				extendsFrom integrationTestCompile
+				canBeResolved = true
+			}
+			integrationTestRuntimeClasspath {
+				extendsFrom integrationTestRuntime
+				canBeResolved = true
+			}
+		}
+
+		project.sourceSets {
+			integrationTest {
+				java.srcDir project.file('src/integration-test/java')
+				resources.srcDir project.file('src/integration-test/resources')
+				compileClasspath = project.sourceSets.main.output + project.sourceSets.test.output + project.configurations.integrationTestCompileClasspath
+				runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntimeClasspath
+			}
+		}
+
+		Task integrationTestTask = project.tasks.create("integrationTest", Test) {
+			group = 'Verification'
+			description = 'Runs the integration tests.'
+			dependsOn 'jar'
+			testClassesDirs = project.sourceSets.integrationTest.output.classesDirs
+			classpath = project.sourceSets.integrationTest.runtimeClasspath
+			shouldRunAfter project.tasks.test
+			useJUnitPlatform()
+		}
+		project.tasks.check.dependsOn integrationTestTask
+
+		project.plugins.withType(IdeaPlugin) {
+			project.idea {
+				module {
+					testSourceDirs += project.file('src/integration-test/java')
+					scopes.TEST.plus += [ project.configurations.integrationTestCompileClasspath ]
+				}
+			}
+		}
+
+		project.plugins.withType(GroovyPlugin) {
+			project.sourceSets {
+				integrationTest {
+					groovy.srcDirs project.file('src/integration-test/groovy')
+				}
+			}
+			project.plugins.withType(IdeaPlugin) {
+				project.idea {
+					module {
+						testSourceDirs += project.file('src/integration-test/groovy')
+					}
+				}
+			}
+		}
+
+		project.plugins.withType(PropDepsPlugin) {
+			project.configurations {
+				integrationTestCompile {
+					extendsFrom optional, provided
+				}
+			}
+		}
+
+		project.plugins.withType(EclipsePlugin) {
+			project.eclipse.classpath {
+				plusConfigurations += [ project.configurations.integrationTestCompileClasspath ]
+			}
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/JacocoPlugin.groovy

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPlugin
+
+/**
+ * Adds a version of jacoco to use and makes check depend on jacocoTestReport.
+ *
+ * @author Rob Winch
+ */
+class JacocoPlugin implements Plugin<Project> {
+
+	@Override
+	void apply(Project project) {
+		project.plugins.withType(JavaPlugin) {
+			project.getPluginManager().apply("jacoco")
+			project.tasks.check.dependsOn project.tasks.jacocoTestReport
+
+			project.jacoco {
+				toolVersion = '0.8.7'
+			}
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/JavadocApiPlugin.groovy

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention;
+
+import java.io.File;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import org.gradle.api.Action;
+import org.gradle.api.JavaVersion
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.javadoc.Javadoc;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author Rob Winch
+ */
+public class JavadocApiPlugin implements Plugin<Project> {
+	Logger logger = LoggerFactory.getLogger(getClass());
+	Set<Pattern> excludes = Collections.singleton(Pattern.compile("test"));
+
+	@Override
+	public void apply(Project project) {
+		logger.info("Applied");
+		Project rootProject = project.getRootProject();
+
+
+		//Task docs = project.getTasks().findByPath("docs") ?: project.getTasks().create("docs");
+		Javadoc api = project.getTasks().create("api", Javadoc);
+
+		api.setGroup("Documentation");
+		api.setDescription("Generates aggregated Javadoc API documentation.");
+		api.doLast {
+			if (JavaVersion.current().isJava11Compatible()) {
+				project.copy({ copy -> copy
+					.from(api.destinationDir)
+					.into(api.destinationDir)
+					.include("element-list")
+					.rename("element-list", "package-list")
+				});
+			}
+		}
+
+		Set<Project> subprojects = rootProject.getSubprojects();
+		for (Project subproject : subprojects) {
+			addProject(api, subproject);
+		}
+
+		if (subprojects.isEmpty()) {
+			addProject(api, project);
+		}
+
+		api.setMaxMemory("1024m");
+		api.setDestinationDir(new File(project.getBuildDir(), "api"));
+
+		project.getPluginManager().apply("io.spring.convention.javadoc-options");
+	}
+
+	public void setExcludes(String... excludes) {
+		if(excludes == null) {
+			this.excludes = Collections.emptySet();
+		}
+		this.excludes = new HashSet<Pattern>(excludes.length);
+		for(String exclude : excludes) {
+			this.excludes.add(Pattern.compile(exclude));
+		}
+	}
+
+	private void addProject(final Javadoc api, final Project project) {
+		for(Pattern exclude : excludes) {
+			if(exclude.matcher(project.getName()).matches()) {
+				logger.info("Skipping {} because it is excluded by {}", project, exclude);
+				return;
+			}
+		}
+		logger.info("Try add sources for {}", project);
+		project.getPlugins().withType(SpringModulePlugin.class).all(new Action<SpringModulePlugin>() {
+			@Override
+			public void execute(SpringModulePlugin plugin) {
+				logger.info("Added sources for {}", project);
+
+				JavaPluginConvention java = project.getConvention().getPlugin(JavaPluginConvention.class);
+				SourceSet mainSourceSet = java.getSourceSets().getByName("main");
+
+				api.setSource(api.getSource().plus(mainSourceSet.getAllJava()));
+				project.getTasks().withType(Javadoc.class).all(new Action<Javadoc>() {
+					@Override
+					public void execute(Javadoc projectJavadoc) {
+						api.setClasspath(api.getClasspath().plus(projectJavadoc.getClasspath()));
+					}
+				});
+			}
+		});
+	}
+}
+

buildSrc/src/main/groovy/io/spring/gradle/convention/JavadocOptionsPlugin.groovy

@@ -0,0 +1,15 @@
+package io.spring.gradle.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.tasks.javadoc.Javadoc
+
+public class JavadocOptionsPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.getTasks().withType(Javadoc).all { t->
+			t.options.addStringOption('Xdoclint:none', '-quiet')
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/ManagementConfigurationPlugin.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.spring.gradle.convention;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaTestFixturesPlugin;
+import org.gradle.api.plugins.PluginContainer;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.maven.MavenPublication;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+import org.springframework.gradle.propdeps.PropDepsPlugin;
+
+/**
+ * Creates a Management configuration that is appropriate for adding a platform to that is not exposed externally. If
+ * the JavaPlugin is applied, the compileClasspath, runtimeClasspath, testCompileClasspath, and testRuntimeClasspath
+ * will extend from it.
+ * @author Rob Winch
+ */
+public class ManagementConfigurationPlugin implements Plugin<Project> {
+
+	public static final String MANAGEMENT_CONFIGURATION_NAME = "management";
+
+	@Override
+	public void apply(Project project) {
+		ConfigurationContainer configurations = project.getConfigurations();
+		configurations.create(MANAGEMENT_CONFIGURATION_NAME, (management) -> {
+			management.setVisible(false);
+			management.setCanBeConsumed(false);
+			management.setCanBeResolved(false);
+
+			PluginContainer plugins = project.getPlugins();
+			plugins.withType(JavaPlugin.class, (javaPlugin) -> {
+				configurations.getByName(JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME).extendsFrom(management);
+				configurations.getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME).extendsFrom(management);
+				configurations.getByName(JavaPlugin.TEST_COMPILE_CLASSPATH_CONFIGURATION_NAME).extendsFrom(management);
+				configurations.getByName(JavaPlugin.TEST_RUNTIME_CLASSPATH_CONFIGURATION_NAME).extendsFrom(management);
+			});
+			plugins.withType(JavaTestFixturesPlugin.class, (javaTestFixturesPlugin) -> {
+				configurations.getByName("testFixturesCompileClasspath").extendsFrom(management);
+				configurations.getByName("testFixturesRuntimeClasspath").extendsFrom(management);
+			});
+			plugins.withType(MavenPublishPlugin.class, (mavenPublish) -> {
+				PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
+				publishing.getPublications().withType(MavenPublication.class, (mavenPublication -> {
+					mavenPublication.versionMapping((versions) ->
+							versions.allVariants(versionMapping -> versionMapping.fromResolutionResult())
+					);
+				}));
+			});
+			plugins.withType(PropDepsPlugin.class, (propDepsPlugin -> {
+				configurations.getByName("optional").extendsFrom(management);
+				configurations.getByName("provided").extendsFrom(management);
+			}));
+		});
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/MavenBomPlugin.groovy

@@ -0,0 +1,18 @@
+package io.spring.gradle.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPlatformPlugin
+import org.sonarqube.gradle.SonarQubePlugin
+import org.springframework.gradle.CopyPropertiesPlugin
+import org.springframework.gradle.maven.SpringMavenPlugin
+
+public class MavenBomPlugin implements Plugin<Project> {
+	static String MAVEN_BOM_TASK_NAME = "mavenBom"
+
+	public void apply(Project project) {
+		project.plugins.apply(JavaPlatformPlugin)
+		project.plugins.apply(SpringMavenPlugin)
+		project.plugins.apply(CopyPropertiesPlugin)
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/RepositoryConventionPlugin.groovy

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2016-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention;
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class RepositoryConventionPlugin implements Plugin<Project> {
+
+	@Override
+	void apply(Project project) {
+		String[] forceMavenRepositories = ((String) project.findProperty("forceMavenRepositories"))?.split(',')
+		boolean isImplicitSnapshotRepository = forceMavenRepositories == null && Utils.isSnapshot(project)
+		boolean isImplicitMilestoneRepository = forceMavenRepositories == null && Utils.isMilestone(project)
+
+		boolean isSnapshot = isImplicitSnapshotRepository || forceMavenRepositories?.contains('snapshot')
+		boolean isMilestone = isImplicitMilestoneRepository || forceMavenRepositories?.contains('milestone')
+
+		project.repositories {
+			if (forceMavenRepositories?.contains('local')) {
+				mavenLocal()
+			}
+			mavenCentral()
+			if (isSnapshot) {
+				maven {
+					name = 'artifactory-snapshot'
+					if (project.hasProperty('artifactoryUsername')) {
+						credentials {
+							username project.artifactoryUsername
+							password project.artifactoryPassword
+						}
+					}
+					url = 'https://repo.spring.io/snapshot/'
+				}
+			}
+			if (isSnapshot || isMilestone) {
+				maven {
+					name = 'artifactory-milestone'
+					if (project.hasProperty('artifactoryUsername')) {
+						credentials {
+							username project.artifactoryUsername
+							password project.artifactoryPassword
+						}
+					}
+					url = 'https://repo.spring.io/milestone/'
+				}
+			}
+			maven {
+				name = 'artifactory-release'
+				if (project.hasProperty('artifactoryUsername')) {
+					credentials {
+						username project.artifactoryUsername
+						password project.artifactoryPassword
+					}
+				}
+				url = 'https://repo.spring.io/release/'
+			}
+			maven {
+				name = 'shibboleth'
+				url = 'https://build.shibboleth.net/nexus/content/repositories/releases/'
+			}
+		}
+	}
+
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/RootProjectPlugin.groovy

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2016-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention
+
+import io.spring.nohttp.gradle.NoHttpPlugin
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.BasePlugin
+import org.gradle.api.plugins.PluginManager
+import org.springframework.gradle.classpath.CheckProhibitedDependenciesLifecyclePlugin
+import org.springframework.gradle.maven.SpringNexusPublishPlugin
+
+class RootProjectPlugin implements Plugin<Project> {
+
+	@Override
+	void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager()
+		pluginManager.apply(BasePlugin)
+		pluginManager.apply(SchemaPlugin)
+		pluginManager.apply(NoHttpPlugin)
+		pluginManager.apply(SpringNexusPublishPlugin)
+		pluginManager.apply(CheckProhibitedDependenciesLifecyclePlugin)
+		pluginManager.apply("org.sonarqube")
+
+		project.repositories.mavenCentral()
+
+		String projectName = Utils.getProjectName(project)
+		project.sonarqube {
+			properties {
+				property "sonar.java.coveragePlugin", "jacoco"
+				property "sonar.projectName", projectName
+				property "sonar.jacoco.reportPath", "${project.buildDir.name}/jacoco.exec"
+				property "sonar.links.homepage", "https://spring.io/${projectName}"
+				property "sonar.links.ci", "https://jenkins.spring.io/job/${projectName}/"
+				property "sonar.links.issue", "https://github.com/spring-projects/${projectName}/issues"
+				property "sonar.links.scm", "https://github.com/spring-projects/${projectName}"
+				property "sonar.links.scm_dev", "https://github.com/spring-projects/${projectName}.git"
+			}
+		}
+
+		def finalizeDeployArtifacts = project.task("finalizeDeployArtifacts")
+		if (Utils.isRelease(project) && project.hasProperty("ossrhUsername")) {
+			finalizeDeployArtifacts.dependsOn project.tasks.closeAndReleaseOssrhStagingRepository
+		}
+	}
+
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/SchemaDeployPlugin.groovy

@@ -0,0 +1,71 @@
+package io.spring.gradle.convention
+
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+public class SchemaDeployPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.getPluginManager().apply('org.hidetake.ssh')
+
+		project.ssh.settings {
+			knownHosts = allowAnyHosts
+		}
+		project.remotes {
+			docs {
+				role 'docs'
+				if (project.hasProperty('deployDocsHost')) {
+					host = project.findProperty('deployDocsHost')
+				} else {
+					host = 'docs.af.pivotal.io'
+				}
+				retryCount = 5 // retry 5 times (default is 0)
+				retryWaitSec = 10 // wait 10 seconds between retries (default is 0)
+				user = project.findProperty('deployDocsSshUsername')
+				if(project.hasProperty('deployDocsSshKeyPath')) {
+					identity = project.file(project.findProperty('deployDocsSshKeyPath'))
+				} else if (project.hasProperty('deployDocsSshKey')) {
+					identity = project.findProperty('deployDocsSshKey')
+				}
+				if(project.hasProperty('deployDocsSshPassphrase')) {
+					passphrase = project.findProperty('deployDocsSshPassphrase')
+				}
+			}
+		}
+
+		project.task('deploySchema') {
+			dependsOn 'schemaZip'
+			doFirst {
+				project.ssh.run {
+					session(project.remotes.docs) {
+						def now = System.currentTimeMillis()
+						def name = project.rootProject.name
+						def version = project.rootProject.version
+						def tempPath = "/tmp/${name}-${now}-schema/".replaceAll(' ', '_')
+
+						execute "mkdir -p $tempPath"
+
+						project.tasks.schemaZip.outputs.each { o ->
+							println "Putting $o.files"
+							put from: o.files, into: tempPath
+						}
+
+						execute "unzip $tempPath*.zip -d $tempPath"
+
+						def extractPath = "/var/www/domains/spring.io/docs/htdocs/autorepo/schema/${name}/${version}/"
+
+						execute "rm -rf $extractPath"
+						execute "mkdir -p $extractPath"
+						execute "rm -f $tempPath*.zip"
+						execute "rm -rf $extractPath*"
+						execute "mv $tempPath/* $extractPath"
+						execute "chmod -R g+w $extractPath"
+					}
+				}
+			}
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/SchemaPlugin.groovy

@@ -0,0 +1,15 @@
+package io.spring.gradle.convention
+
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+public class SchemaPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.getPluginManager().apply(SchemaZipPlugin)
+		project.getPluginManager().apply(SchemaDeployPlugin)
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/SchemaZipPlugin.groovy

@@ -0,0 +1,43 @@
+package io.spring.gradle.convention
+
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+public class SchemaZipPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		Zip schemaZip = project.tasks.create('schemaZip', Zip)
+		schemaZip.group = 'Distribution'
+		schemaZip.archiveBaseName = project.rootProject.name
+		schemaZip.archiveClassifier = 'schema'
+		schemaZip.description = "Builds -${schemaZip.archiveClassifier} archive containing all " +
+			"XSDs for deployment at static.springframework.org/schema."
+
+		project.rootProject.subprojects.each { module ->
+
+			module.getPlugins().withType(JavaPlugin.class).all {
+				def Properties schemas = new Properties();
+
+				module.sourceSets.main.resources.find {
+					it.path.endsWith('META-INF/spring.schemas')
+				}?.withInputStream { schemas.load(it) }
+
+				for (def key : schemas.keySet()) {
+					def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
+					assert shortName != key
+					File xsdFile = module.sourceSets.main.resources.find {
+						it.path.endsWith(schemas.get(key))
+					}
+					assert xsdFile != null
+					schemaZip.into (shortName) {
+						duplicatesStrategy 'exclude'
+						from xsdFile.path
+					}
+				}
+			}
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/SortedProperties.groovy

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.spring.gradle.convention;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * A Properties which sorts they keys so that they can be written to a File with
+ * the keys sorted.
+ *
+ * @author Rob Winch
+ *
+ */
+class SortedProperties extends Properties {
+	private static final long serialVersionUID = -6199017589626540836L;
+
+	public Enumeration<Object> keys() {
+		Enumeration<Object> keysEnum = super.keys();
+		List<Object> keyList = new ArrayList<Object>();
+
+		while (keysEnum.hasMoreElements()) {
+			keyList.add(keysEnum.nextElement());
+		}
+
+		Collections.sort(keyList, new Comparator<Object>() {
+			@Override
+			public int compare(Object o1, Object o2) {
+				return o1.toString().compareTo(o2.toString());
+			}
+		});
+
+		return Collections.enumeration(keyList);
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/SpringModulePlugin.groovy

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2016-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention;
+
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.gradle.api.plugins.MavenPlugin;
+import org.gradle.api.plugins.PluginManager
+import org.springframework.gradle.classpath.CheckClasspathForProhibitedDependenciesPlugin;
+import org.springframework.gradle.maven.SpringMavenPlugin;
+
+/**
+ * @author Rob Winch
+ */
+class SpringModulePlugin extends AbstractSpringJavaPlugin {
+
+	@Override
+	void additionalPlugins(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(JavaLibraryPlugin.class)
+		pluginManager.apply(SpringMavenPlugin.class);
+		pluginManager.apply(CheckClasspathForProhibitedDependenciesPlugin.class);
+		pluginManager.apply("io.spring.convention.jacoco");
+
+		def deployArtifacts = project.task("deployArtifacts")
+		deployArtifacts.group = 'Deploy tasks'
+		deployArtifacts.description = "Deploys the artifacts to either Artifactory or Maven Central"
+		if (!Utils.isRelease(project)) {
+			deployArtifacts.dependsOn project.tasks.artifactoryPublish
+		}
+	}
+
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/SpringTestPlugin.groovy

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package io.spring.gradle.convention;
+
+import org.gradle.api.Project;
+
+/**
+ * @author Rob Winch
+ */
+public class SpringTestPlugin extends AbstractSpringJavaPlugin {
+
+	@Override
+	public void additionalPlugins(Project project) {
+		project.sonarqube.skipProject = true
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/TestsConfigurationPlugin.groovy

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package io.spring.gradle.convention;
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.jvm.tasks.Jar
+
+/**
+ * Adds the ability to depends on the test jar within other projects using:
+ *
+ * <code>
+ * testCompile project(path: ':foo', configuration: 'tests')
+ * </code>
+ *
+ * @author Rob Winch
+ */
+public class TestsConfigurationPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.plugins.withType(JavaPlugin) {
+			applyJavaProject(project)
+		}
+	}
+
+	private void applyJavaProject(Project project) {
+		project.configurations {
+			tests.extendsFrom testRuntime, testRuntimeClasspath
+		}
+
+		project.tasks.create('testJar', Jar) {
+			classifier = 'test'
+			from project.sourceSets.test.output
+		}
+
+		project.artifacts {
+			tests project.testJar
+		}
+	}
+}

buildSrc/src/main/groovy/io/spring/gradle/convention/Utils.groovy

@@ -0,0 +1,34 @@
+package io.spring.gradle.convention;
+
+import org.gradle.api.Project;
+
+public class Utils {
+
+	static String getProjectName(Project project) {
+		String projectName = project.getRootProject().getName();
+		if(projectName.endsWith("-build")) {
+			projectName = projectName.substring(0, projectName.length() - "-build".length());
+		}
+		return projectName;
+	}
+
+	static boolean isSnapshot(Project project) {
+		String projectVersion = projectVersion(project)
+		return projectVersion.matches('^.*([.-]BUILD)?-SNAPSHOT$')
+	}
+
+	static boolean isMilestone(Project project) {
+		String projectVersion = projectVersion(project)
+		return projectVersion.matches('^.*[.-]M\\d+$') || projectVersion.matches('^.*[.-]RC\\d+$')
+	}
+
+	static boolean isRelease(Project project) {
+		return !(isSnapshot(project) || isMilestone(project))
+	}
+
+	private static String projectVersion(Project project) {
+		return String.valueOf(project.getVersion());
+	}
+
+	private Utils() {}
+}

buildSrc/src/main/java/lock/GlobalLockPlugin.java

@@ -0,0 +1,16 @@
+package lock;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+/**
+ * @author Rob Winch
+ */
+public class GlobalLockPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getTasks().register("writeLocks", GlobalLockTask.class, (writeAll) -> {
+			writeAll.setDescription("Writes the locks for all projects");
+		});
+	}
+}

buildSrc/src/main/java/lock/GlobalLockTask.java

@@ -0,0 +1,40 @@
+package lock;
+
+import org.gradle.api.Action;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.tasks.TaskAction;
+
+import java.util.function.Consumer;
+
+/**
+ * @author Rob Winch
+ */
+public class GlobalLockTask extends DefaultTask {
+	@TaskAction
+	public void lock() {
+		Project taskProject = getProject();
+		if (!taskProject.getGradle().getStartParameter().isWriteDependencyLocks()) {
+			throw new IllegalStateException("You just specify --write-locks argument");
+		}
+		writeLocksFor(taskProject);
+		taskProject.getSubprojects().forEach(new Consumer<Project>() {
+			@Override
+			public void accept(Project subproject) {
+				writeLocksFor(subproject);
+			}
+		});
+	}
+
+	private void writeLocksFor(Project project) {
+		project.getConfigurations().configureEach(new Action<Configuration>() {
+			@Override
+			public void execute(Configuration configuration) {
+				if (configuration.isCanBeResolved()) {
+					configuration.resolve();
+				}
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/CopyPropertiesPlugin.java

@@ -0,0 +1,22 @@
+package org.springframework.gradle;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+public class CopyPropertiesPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		copyPropertyFromRootProjectTo("group", project);
+		copyPropertyFromRootProjectTo("version", project);
+		copyPropertyFromRootProjectTo("description", project);
+	}
+
+
+	private void copyPropertyFromRootProjectTo(String propertyName, Project project) {
+		Project rootProject = project.getRootProject();
+		Object property = rootProject.findProperty(propertyName);
+		if(property != null) {
+			project.setProperty(propertyName, property);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/antora/AntoraVersionPlugin.java

@@ -0,0 +1,71 @@
+package org.springframework.gradle.antora;
+
+import org.gradle.api.Action;
+import org.gradle.api.GradleException;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.language.base.plugins.LifecycleBasePlugin;
+
+public class AntoraVersionPlugin implements Plugin<Project> {
+	public static final String ANTORA_CHECK_VERSION_TASK_NAME = "antoraCheckVersion";
+
+	@Override
+	public void apply(Project project) {
+		TaskProvider<CheckAntoraVersionTask> antoraCheckVersion = project.getTasks().register(ANTORA_CHECK_VERSION_TASK_NAME, CheckAntoraVersionTask.class, new Action<CheckAntoraVersionTask>() {
+			@Override
+			public void execute(CheckAntoraVersionTask antoraCheckVersion) {
+				antoraCheckVersion.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
+				antoraCheckVersion.setDescription("Checks the antora.yml version properties match the Gradle version");
+				antoraCheckVersion.getAntoraVersion().convention(project.provider(() -> getDefaultAntoraVersion(project)));
+				antoraCheckVersion.getAntoraPrerelease().convention(project.provider(() -> getDefaultAntoraPrerelease(project)));
+				antoraCheckVersion.getAntoraDisplayVersion().convention(project.provider(() -> getDefaultAntoraDisplayVersion(project)));
+				antoraCheckVersion.getAntoraYmlFile().fileProvider(project.provider(() -> project.file("antora.yml")));
+			}
+		});
+		project.getPlugins().withType(LifecycleBasePlugin.class, new Action<LifecycleBasePlugin>() {
+			@Override
+			public void execute(LifecycleBasePlugin lifecycleBasePlugin) {
+				project.getTasks().named(LifecycleBasePlugin.CHECK_TASK_NAME).configure(new Action<Task>() {
+					@Override
+					public void execute(Task check) {
+						check.dependsOn(antoraCheckVersion);
+					}
+				});
+			}
+		});
+		 project.getTasks().register("antoraUpdateVersion", UpdateAntoraVersionTask.class, new Action<UpdateAntoraVersionTask>() {
+			@Override
+			public void execute(UpdateAntoraVersionTask antoraUpdateVersion) {
+				antoraUpdateVersion.setGroup("Release");
+				antoraUpdateVersion.setDescription("Updates the antora.yml version properties to match the Gradle version");
+				antoraUpdateVersion.getAntoraYmlFile().fileProvider(project.provider(() -> project.file("antora.yml")));
+			}
+		});
+	}
+
+	private static String getDefaultAntoraVersion(Project project) {
+		String projectVersion = getProjectVersion(project);
+		return AntoraVersionUtils.getDefaultAntoraVersion(projectVersion);
+	}
+
+	private static String getDefaultAntoraPrerelease(Project project) {
+		String projectVersion = getProjectVersion(project);
+		return AntoraVersionUtils.getDefaultAntoraPrerelease(projectVersion);
+	}
+
+	private static String getDefaultAntoraDisplayVersion(Project project) {
+		String projectVersion = getProjectVersion(project);
+		return AntoraVersionUtils.getDefaultAntoraDisplayVersion(projectVersion);
+	}
+
+	private static String getProjectVersion(Project project) {
+		Object projectVersion = project.getVersion();
+		if (projectVersion == null) {
+			throw new GradleException("Please define antoraVersion and antoraPrerelease on " + ANTORA_CHECK_VERSION_TASK_NAME + " or provide a Project version so they can be defaulted");
+		}
+		return String.valueOf(projectVersion);
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/antora/AntoraVersionUtils.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.antora;
+
+public class AntoraVersionUtils {
+
+	public static String getDefaultAntoraVersion(String projectVersion) {
+		int preReleaseIndex = getSnapshotIndex(projectVersion);
+		return isSnapshot(projectVersion) ? projectVersion.substring(0, preReleaseIndex) : projectVersion;
+	}
+
+	public static String getDefaultAntoraPrerelease(String projectVersion) {
+		if (isSnapshot(projectVersion)) {
+			int preReleaseIndex = getSnapshotIndex(projectVersion);
+			return projectVersion.substring(preReleaseIndex);
+		}
+		if (isPreRelease(projectVersion)) {
+			return Boolean.TRUE.toString();
+		}
+		return null;
+	}
+
+	public static String getDefaultAntoraDisplayVersion(String projectVersion) {
+		if (!isSnapshot(projectVersion) && isPreRelease(projectVersion)) {
+			return getDefaultAntoraVersion(projectVersion);
+		}
+		return null;
+	}
+
+	private static boolean isSnapshot(String projectVersion) {
+		return getSnapshotIndex(projectVersion) >= 0;
+	}
+
+	private static int getSnapshotIndex(String projectVersion) {
+		return projectVersion.lastIndexOf("-SNAPSHOT");
+	}
+
+	private static boolean isPreRelease(String projectVersion) {
+		return projectVersion.lastIndexOf("-") >= 0;
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/antora/CheckAntoraVersionTask.java

@@ -0,0 +1,96 @@
+package org.springframework.gradle.antora;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.GradleException;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.TaskAction;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+import org.yaml.snakeyaml.representer.Representer;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+public abstract class CheckAntoraVersionTask extends DefaultTask {
+
+	@TaskAction
+	public void check() throws FileNotFoundException {
+		File antoraYmlFile = getAntoraYmlFile().getAsFile().get();
+		String expectedAntoraVersion = getAntoraVersion().get();
+		String expectedAntoraPrerelease = getAntoraPrerelease().getOrElse(null);
+		String expectedAntoraDisplayVersion = getAntoraDisplayVersion().getOrElse(null);
+
+		Representer representer = new Representer();
+		representer.getPropertyUtils().setSkipMissingProperties(true);
+
+		Yaml yaml = new Yaml(new Constructor(AntoraYml.class), representer);
+		AntoraYml antoraYml = yaml.load(new FileInputStream(antoraYmlFile));
+
+		String actualAntoraPrerelease = antoraYml.getPrerelease();
+		boolean preReleaseMatches = antoraYml.getPrerelease() == null && expectedAntoraPrerelease == null ||
+				(actualAntoraPrerelease != null && actualAntoraPrerelease.equals(expectedAntoraPrerelease));
+		String actualAntoraDisplayVersion = antoraYml.getDisplay_version();
+		boolean displayVersionMatches = antoraYml.getDisplay_version() == null && expectedAntoraDisplayVersion == null ||
+				(actualAntoraDisplayVersion != null && actualAntoraDisplayVersion.equals(expectedAntoraDisplayVersion));
+		String actualAntoraVersion = antoraYml.getVersion();
+		if (!preReleaseMatches ||
+				!displayVersionMatches ||
+				!expectedAntoraVersion.equals(actualAntoraVersion)) {
+			throw new GradleException("The Gradle version of '" + getProject().getVersion() + "' should have version: '"
+					+ expectedAntoraVersion + "' prerelease: '" + expectedAntoraPrerelease + "' display_version: '"
+					+ expectedAntoraDisplayVersion + "' defined in " + antoraYmlFile + " but got version: '"
+					+ actualAntoraVersion + "' prerelease: '" + actualAntoraPrerelease + "' display_version: '" + actualAntoraDisplayVersion + "'");
+		}
+	}
+
+	@InputFile
+	public abstract RegularFileProperty getAntoraYmlFile();
+
+	@Input
+	public abstract Property<String> getAntoraVersion();
+
+	@Input
+	@Optional
+	public abstract Property<String> getAntoraPrerelease();
+
+	@Input
+	@Optional
+	public abstract Property<String> getAntoraDisplayVersion();
+
+	public static class AntoraYml {
+		private String version;
+
+		private String prerelease;
+
+		private String display_version;
+
+		public String getVersion() {
+			return version;
+		}
+
+		public void setVersion(String version) {
+			this.version = version;
+		}
+
+		public String getPrerelease() {
+			return prerelease;
+		}
+
+		public void setPrerelease(String prerelease) {
+			this.prerelease = prerelease;
+		}
+
+		public String getDisplay_version() {
+			return display_version;
+		}
+
+		public void setDisplay_version(String display_version) {
+			this.display_version = display_version;
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/antora/UpdateAntoraVersionTask.java

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.antora;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.GradleException;
+import org.gradle.api.Project;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.Tag;
+import org.yaml.snakeyaml.representer.Representer;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import org.springframework.gradle.github.milestones.NextVersionYml;
+
+public abstract class UpdateAntoraVersionTask extends DefaultTask {
+
+	@TaskAction
+	public void update() throws IOException {
+		String projectVersion = getProject().getVersion().toString();
+		File antoraYmlFile = getAntoraYmlFile().getAsFile().get();
+		String updatedAntoraVersion = AntoraVersionUtils.getDefaultAntoraVersion(projectVersion);
+		String updatedAntoraPrerelease = AntoraVersionUtils.getDefaultAntoraPrerelease(projectVersion);
+		String updatedAntoraDisplayVersion = AntoraVersionUtils.getDefaultAntoraDisplayVersion(projectVersion);
+
+		Representer representer = new Representer();
+		representer.getPropertyUtils().setSkipMissingProperties(true);
+
+		Yaml yaml = new Yaml(new Constructor(AntoraYml.class), representer);
+		AntoraYml antoraYml = yaml.load(new FileInputStream(antoraYmlFile));
+
+		System.out.println("Updating the version parameters in " + antoraYmlFile.getName() + " to version: "
+				+ updatedAntoraVersion + ", prerelease: " + updatedAntoraPrerelease + ", display_version: "
+				+ updatedAntoraDisplayVersion);
+		antoraYml.setVersion(updatedAntoraVersion);
+		antoraYml.setPrerelease(updatedAntoraPrerelease);
+		antoraYml.setDisplay_version(updatedAntoraDisplayVersion);
+
+		FileWriter outputWriter = new FileWriter(antoraYmlFile);
+		getYaml().dump(antoraYml, outputWriter);
+	}
+
+	@InputFile
+	public abstract RegularFileProperty getAntoraYmlFile();
+
+	public static class AntoraYml {
+
+		private String name;
+
+		private String version;
+
+		private String prerelease;
+
+		private String display_version;
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public String getVersion() {
+			return version;
+		}
+
+		public void setVersion(String version) {
+			this.version = version;
+		}
+
+		public String getPrerelease() {
+			return prerelease;
+		}
+
+		public void setPrerelease(String prerelease) {
+			this.prerelease = prerelease;
+		}
+
+		public String getDisplay_version() {
+			return display_version;
+		}
+
+		public void setDisplay_version(String display_version) {
+			this.display_version = display_version;
+		}
+
+	}
+
+	private Yaml getYaml() {
+		Representer representer = new Representer() {
+			@Override
+			protected NodeTuple representJavaBeanProperty(Object javaBean,
+					org.yaml.snakeyaml.introspector.Property property, Object propertyValue, Tag customTag) {
+				// Don't write out null values
+				if (propertyValue == null) {
+					return null;
+				}
+				else {
+					return super.representJavaBeanProperty(javaBean, property, propertyValue, customTag);
+				}
+			}
+		};
+		representer.addClassTag(AntoraYml.class, Tag.MAP);
+		DumperOptions ymlOptions = new DumperOptions();
+		ymlOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+		ymlOptions.setDefaultScalarStyle(DumperOptions.ScalarStyle.SINGLE_QUOTED);
+		return new Yaml(representer, ymlOptions);
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/classpath/CheckClasspathForProhibitedDependencies.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2012-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.classpath;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.GradleException;
+import org.gradle.api.Task;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ModuleVersionIdentifier;
+import org.gradle.api.artifacts.ResolvedConfiguration;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.IOException;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+/**
+ * A {@link Task} for checking the classpath for prohibited dependencies.
+ *
+ * @author Andy Wilkinson
+ */
+public class CheckClasspathForProhibitedDependencies extends DefaultTask {
+
+	private Configuration classpath;
+
+	public CheckClasspathForProhibitedDependencies() {
+		getOutputs().upToDateWhen((task) -> true);
+	}
+
+	public void setClasspath(Configuration classpath) {
+		this.classpath = classpath;
+	}
+
+	@Classpath
+	public FileCollection getClasspath() {
+		return this.classpath;
+	}
+
+	@TaskAction
+	public void checkForProhibitedDependencies() throws IOException {
+		ResolvedConfiguration resolvedConfiguration = this.classpath.getResolvedConfiguration();
+		TreeSet<String> prohibited = resolvedConfiguration.getResolvedArtifacts().stream()
+				.map((artifact) -> artifact.getModuleVersion().getId()).filter(this::prohibited)
+				.map((id) -> id.getGroup() + ":" + id.getName()).collect(Collectors.toCollection(TreeSet::new));
+		if (!prohibited.isEmpty()) {
+			StringBuilder message = new StringBuilder(String.format("Found prohibited dependencies in '%s':%n", this.classpath.getName()));
+			for (String dependency : prohibited) {
+				message.append(String.format("    %s%n", dependency));
+			}
+			throw new GradleException(message.toString());
+		}
+	}
+
+	private boolean prohibited(ModuleVersionIdentifier id) {
+		String group = id.getGroup();
+		if (group.equals("javax.batch")) {
+			return false;
+		}
+		if (group.equals("javax.cache")) {
+			return false;
+		}
+		if (group.equals("javax.money")) {
+			return false;
+		}
+		if (group.startsWith("javax")) {
+			return true;
+		}
+		if (group.equals("commons-logging")) {
+			return true;
+		}
+		if (group.equals("org.slf4j") && id.getName().equals("jcl-over-slf4j")) {
+			return true;
+		}
+		if (group.startsWith("org.jboss.spec")) {
+			return true;
+		}
+		if (group.equals("org.apache.geronimo.specs")) {
+			return true;
+		}
+		return false;
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/classpath/CheckClasspathForProhibitedDependenciesPlugin.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2012-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.classpath;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.tasks.SourceSetContainer;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.language.base.plugins.LifecycleBasePlugin;
+import org.springframework.util.StringUtils;
+
+/**
+ * @author Andy Wilkinson
+ * @author Rob Winch
+ */
+public class CheckClasspathForProhibitedDependenciesPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().apply(CheckProhibitedDependenciesLifecyclePlugin.class);
+		project.getPlugins().withType(JavaBasePlugin.class, javaBasePlugin -> {
+			configureProhibitedDependencyChecks(project);
+		});
+	}
+
+	private void configureProhibitedDependencyChecks(Project project) {
+		SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
+		sourceSets.all((sourceSet) -> createProhibitedDependenciesChecks(project,
+				sourceSet.getCompileClasspathConfigurationName(), sourceSet.getRuntimeClasspathConfigurationName()));
+	}
+
+	private void createProhibitedDependenciesChecks(Project project, String... configurationNames) {
+		ConfigurationContainer configurations = project.getConfigurations();
+		for (String configurationName : configurationNames) {
+			Configuration configuration = configurations.getByName(configurationName);
+			createProhibitedDependenciesCheck(configuration, project);
+		}
+	}
+
+	private void createProhibitedDependenciesCheck(Configuration classpath, Project project) {
+		String taskName = "check" + StringUtils.capitalize(classpath.getName() + "ForProhibitedDependencies");
+		TaskProvider<CheckClasspathForProhibitedDependencies> checkClasspathTask = project.getTasks().register(taskName,
+				CheckClasspathForProhibitedDependencies.class, checkClasspath -> {
+					checkClasspath.setGroup(LifecycleBasePlugin.CHECK_TASK_NAME);
+					checkClasspath.setDescription("Checks " + classpath.getName() + " for prohibited dependencies");
+					checkClasspath.setClasspath(classpath);
+				});
+		project.getTasks().named(CheckProhibitedDependenciesLifecyclePlugin.CHECK_PROHIBITED_DEPENDENCIES_TASK_NAME, checkProhibitedTask -> checkProhibitedTask.dependsOn(checkClasspathTask));
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/classpath/CheckProhibitedDependenciesLifecyclePlugin.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2012-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.classpath;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.tasks.TaskProvider;
+
+/**
+ * @author Rob Winch
+ */
+public class CheckProhibitedDependenciesLifecyclePlugin implements Plugin<Project> {
+	public static final String CHECK_PROHIBITED_DEPENDENCIES_TASK_NAME = "checkForProhibitedDependencies";
+
+	@Override
+	public void apply(Project project) {
+		TaskProvider<Task> checkProhibitedDependencies = project.getTasks().register(CheckProhibitedDependenciesLifecyclePlugin.CHECK_PROHIBITED_DEPENDENCIES_TASK_NAME, task -> {
+			task.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
+			task.setDescription("Checks both the compile/runtime classpath of every SourceSet for prohibited dependencies");
+		});
+		project.getTasks().named(JavaBasePlugin.CHECK_TASK_NAME, checkTask -> {
+			checkTask.dependsOn(checkProhibitedDependencies);
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/RepositoryRef.java

@@ -0,0 +1,70 @@
+package org.springframework.gradle.github;
+
+import java.io.Serializable;
+
+public class RepositoryRef implements Serializable {
+
+	private static final long serialVersionUID = 7151218536746822797L;
+
+	private String owner;
+
+	private String name;
+
+	public RepositoryRef() {
+	}
+
+	public RepositoryRef(String owner, String name) {
+		this.owner = owner;
+		this.name = name;
+	}
+
+	public String getOwner() {
+		return owner;
+	}
+
+	public void setOwner(String owner) {
+		this.owner = owner;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	@Override
+	public String toString() {
+		return "RepositoryRef{" +
+				"owner='" + owner + '\'' +
+				", name='" + name + '\'' +
+				'}';
+	}
+
+	public static RepositoryRefBuilder owner(String owner) {
+		return new RepositoryRefBuilder().owner(owner);
+	}
+
+	public static final class RepositoryRefBuilder {
+		private String owner;
+		private String repository;
+
+		private RepositoryRefBuilder() {
+		}
+
+		private RepositoryRefBuilder owner(String owner) {
+			this.owner = owner;
+			return this;
+		}
+
+		public RepositoryRefBuilder repository(String repository) {
+			this.repository = repository;
+			return this;
+		}
+
+		public RepositoryRef build() {
+			return new RepositoryRef(owner, repository);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/changelog/GitHubChangelogPlugin.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.changelog;
+
+import java.io.File;
+import java.nio.file.Paths;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.DependencySet;
+import org.gradle.api.artifacts.repositories.ExclusiveContentRepository;
+import org.gradle.api.artifacts.repositories.InclusiveRepositoryContentDescriptor;
+import org.gradle.api.artifacts.repositories.IvyArtifactRepository;
+import org.gradle.api.artifacts.repositories.IvyPatternRepositoryLayout;
+import org.gradle.api.tasks.JavaExec;
+
+public class GitHubChangelogPlugin implements Plugin<Project> {
+
+	public static final String CHANGELOG_GENERATOR_CONFIGURATION_NAME = "changelogGenerator";
+	public static final String RELEASE_NOTES_PATH = "changelog/release-notes.md";
+
+	@Override
+	public void apply(Project project) {
+		createRepository(project);
+		createChangelogGeneratorConfiguration(project);
+		project.getTasks().register("generateChangelog", JavaExec.class, new Action<JavaExec>() {
+			@Override
+			public void execute(JavaExec generateChangelog) {
+				File outputFile = project.file(Paths.get(project.getBuildDir().getPath(), RELEASE_NOTES_PATH));
+				outputFile.getParentFile().mkdirs();
+				generateChangelog.setGroup("Release");
+				generateChangelog.setDescription("Generates the changelog");
+				generateChangelog.setWorkingDir(project.getRootDir());
+				generateChangelog.classpath(project.getConfigurations().getAt(CHANGELOG_GENERATOR_CONFIGURATION_NAME));
+				generateChangelog.doFirst(new Action<Task>() {
+					@Override
+					public void execute(Task task) {
+						generateChangelog.args("--spring.config.location=scripts/release/release-notes-sections.yml", project.property("nextVersion"), outputFile.toString());
+					}
+				});
+			}
+		});
+	}
+
+	private void createChangelogGeneratorConfiguration(Project project) {
+		project.getConfigurations().create(CHANGELOG_GENERATOR_CONFIGURATION_NAME, new Action<Configuration>() {
+			@Override
+			public void execute(Configuration configuration) {
+				configuration.defaultDependencies(new Action<DependencySet>() {
+					@Override
+					public void execute(DependencySet dependencies) {
+						dependencies.add(project.getDependencies().create("spring-io:github-changelog-generator:0.0.6"));
+					}
+				});
+			}
+		});
+	}
+
+	private void createRepository(Project project) {
+		IvyArtifactRepository repository = project.getRepositories().ivy(new Action<IvyArtifactRepository>() {
+			@Override
+			public void execute(IvyArtifactRepository repository) {
+				repository.setUrl("https://github.com/");
+				repository.patternLayout(new Action<IvyPatternRepositoryLayout>() {
+					@Override
+					public void execute(IvyPatternRepositoryLayout layout) {
+						layout.artifact("[organization]/[artifact]/releases/download/v[revision]/[artifact].[ext]");
+					}
+				});
+				repository.getMetadataSources().artifact();
+			}
+		});
+		project.getRepositories().exclusiveContent(new Action<ExclusiveContentRepository>() {
+			@Override
+			public void execute(ExclusiveContentRepository exclusiveContentRepository) {
+				exclusiveContentRepository.forRepositories(repository);
+				exclusiveContentRepository.filter(new Action<InclusiveRepositoryContentDescriptor>() {
+					@Override
+					public void execute(InclusiveRepositoryContentDescriptor descriptor) {
+						descriptor.includeGroup("spring-io");
+					}
+				});
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/milestones/GitHubMilestoneApi.java

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.milestones;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.google.common.reflect.TypeToken;
+import com.google.gson.Gson;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+import org.springframework.gradle.github.RepositoryRef;
+
+public class GitHubMilestoneApi {
+	private String baseUrl = "https://api.github.com";
+
+	private OkHttpClient client;
+
+	private Gson gson = new Gson();
+
+	public GitHubMilestoneApi() {
+		this.client = new OkHttpClient.Builder().build();
+	}
+
+	public GitHubMilestoneApi(String gitHubToken) {
+		this.client = new OkHttpClient.Builder()
+				.addInterceptor(new AuthorizationInterceptor(gitHubToken))
+				.build();
+	}
+
+	public void setBaseUrl(String baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+
+	public long findMilestoneNumberByTitle(RepositoryRef repositoryRef, String milestoneTitle) {
+		String url = this.baseUrl + "/repos/" + repositoryRef.getOwner() + "/" + repositoryRef.getName() + "/milestones?per_page=100";
+		Request request = new Request.Builder().get().url(url)
+				.build();
+		try {
+			Response response = this.client.newCall(request).execute();
+			if (!response.isSuccessful()) {
+				throw new RuntimeException("Could not find milestone with title " + milestoneTitle + " for repository " + repositoryRef + ". Response " + response);
+			}
+			List<Milestone> milestones = this.gson.fromJson(response.body().charStream(), new TypeToken<List<Milestone>>(){}.getType());
+			for (Milestone milestone : milestones) {
+				if (milestoneTitle.equals(milestone.getTitle())) {
+					return milestone.getNumber();
+				}
+			}
+			if (milestones.size() <= 100) {
+				throw new RuntimeException("Could not find open milestone with title " + milestoneTitle + " for repository " + repositoryRef + " Got " + milestones);
+			}
+			throw new RuntimeException("It is possible there are too many open milestones open (only 100 are supported). Could not find open milestone with title " + milestoneTitle + " for repository " + repositoryRef + " Got " + milestones);
+		} catch (IOException e) {
+			throw new RuntimeException("Could not find open milestone with title " + milestoneTitle + " for repository " + repositoryRef, e);
+		}
+	}
+
+	public boolean isOpenIssuesForMilestoneNumber(RepositoryRef repositoryRef, long milestoneNumber) {
+		String url = this.baseUrl + "/repos/" + repositoryRef.getOwner() + "/" + repositoryRef.getName() + "/issues?per_page=1&milestone=" + milestoneNumber;
+		Request request = new Request.Builder().get().url(url)
+				.build();
+		try {
+			Response response = this.client.newCall(request).execute();
+			if (!response.isSuccessful()) {
+				throw new RuntimeException("Could not find issues for milestone number " + milestoneNumber + " for repository " + repositoryRef + ". Response " + response);
+			}
+			List<Object> issues = this.gson.fromJson(response.body().charStream(), new TypeToken<List<Object>>(){}.getType());
+			return !issues.isEmpty();
+		} catch (IOException e) {
+			throw new RuntimeException("Could not find issues for milestone number " + milestoneNumber + " for repository " + repositoryRef, e);
+		}
+	}
+
+	/**
+	 * Check if the given milestone is due today or past due.
+	 *
+	 * @param repositoryRef The repository owner/name
+	 * @param milestoneTitle The title of the milestone whose due date should be checked
+	 * @return true if the given milestone is due today or past due, false otherwise
+	 */
+	public boolean isMilestoneDueToday(RepositoryRef repositoryRef, String milestoneTitle) {
+		String url = this.baseUrl + "/repos/" + repositoryRef.getOwner() + "/" + repositoryRef.getName()
+				+ "/milestones?per_page=100";
+		Request request = new Request.Builder().get().url(url).build();
+		try {
+			Response response = this.client.newCall(request).execute();
+			if (!response.isSuccessful()) {
+				throw new RuntimeException("Could not find milestone with title " + milestoneTitle + " for repository "
+						+ repositoryRef + ". Response " + response);
+			}
+			List<Milestone> milestones = this.gson.fromJson(response.body().charStream(),
+					new TypeToken<List<Milestone>>() {
+					}.getType());
+			for (Milestone milestone : milestones) {
+				if (milestoneTitle.equals(milestone.getTitle())) {
+					Instant now = Instant.now();
+					return milestone.getDueOn() != null && now.isAfter(milestone.getDueOn().toInstant());
+				}
+			}
+			if (milestones.size() <= 100) {
+				throw new RuntimeException("Could not find open milestone with title " + milestoneTitle
+						+ " for repository " + repositoryRef + " Got " + milestones);
+			}
+			throw new RuntimeException(
+					"It is possible there are too many open milestones open (only 100 are supported). Could not find open milestone with title "
+							+ milestoneTitle + " for repository " + repositoryRef + " Got " + milestones);
+		}
+		catch (IOException e) {
+			throw new RuntimeException(
+					"Could not find open milestone with title " + milestoneTitle + " for repository " + repositoryRef,
+					e);
+		}
+	}
+
+	/**
+	 * Calculate the next release version based on the current version.
+	 *
+	 * The current version must conform to the pattern MAJOR.MINOR.PATCH-SNAPSHOT. If the
+	 * current version is a snapshot of a patch release, then the patch release will be
+	 * returned. For example, if the current version is 5.6.1-SNAPSHOT, then 5.6.1 will be
+	 * returned. If the current version is a snapshot of a version that is not GA (i.e the
+	 * PATCH segment is 0), then GitHub will be queried to find the next milestone or
+	 * release candidate. If no pre-release versions are found, then the next version will
+	 * be assumed to be the GA.
+	 * @param repositoryRef The repository owner/name
+	 * @param currentVersion The current project version
+	 * @return the next matching milestone/release candidate or null if none exist
+	 */
+	public String getNextReleaseMilestone(RepositoryRef repositoryRef, String currentVersion) {
+		Pattern snapshotPattern = Pattern.compile("^([0-9]+)\\.([0-9]+)\\.([0-9]+)-SNAPSHOT$");
+		Matcher snapshotVersion = snapshotPattern.matcher(currentVersion);
+
+		if (snapshotVersion.find()) {
+			String patchSegment = snapshotVersion.group(3);
+			String currentVersionNoIdentifier = currentVersion.replace("-SNAPSHOT", "");
+			if (patchSegment.equals("0")) {
+				String nextPreRelease = getNextPreRelease(repositoryRef, currentVersionNoIdentifier);
+				return nextPreRelease != null ? nextPreRelease : currentVersionNoIdentifier;
+			}
+			else {
+				return currentVersionNoIdentifier;
+			}
+		}
+		else {
+			throw new IllegalStateException(
+					"Cannot calculate next release version because the current project version does not conform to the expected format");
+		}
+	}
+
+	/**
+	 * Calculate the next pre-release version (milestone or release candidate) based on
+	 * the current version.
+	 *
+	 * The current version must conform to the pattern MAJOR.MINOR.PATCH. If no matching
+	 * milestone or release candidate is found in GitHub then it will return null.
+	 * @param repositoryRef The repository owner/name
+	 * @param currentVersionNoIdentifier The current project version without any
+	 * identifier
+	 * @return the next matching milestone/release candidate or null if none exist
+	 */
+	private String getNextPreRelease(RepositoryRef repositoryRef, String currentVersionNoIdentifier) {
+		String url = this.baseUrl + "/repos/" + repositoryRef.getOwner() + "/" + repositoryRef.getName()
+				+ "/milestones?per_page=100";
+		Request request = new Request.Builder().get().url(url).build();
+		try {
+			Response response = this.client.newCall(request).execute();
+			if (!response.isSuccessful()) {
+				throw new RuntimeException(
+						"Could not get milestones for repository " + repositoryRef + ". Response " + response);
+			}
+			List<Milestone> milestones = this.gson.fromJson(response.body().charStream(),
+					new TypeToken<List<Milestone>>() {
+					}.getType());
+			Optional<String> nextPreRelease = milestones.stream().map(Milestone::getTitle)
+					.filter(m -> m.startsWith(currentVersionNoIdentifier + "-"))
+					.min((m1, m2) -> {
+						Pattern preReleasePattern = Pattern.compile("^.*-([A-Z]+)([0-9]+)$");
+						Matcher matcher1 = preReleasePattern.matcher(m1);
+						Matcher matcher2 = preReleasePattern.matcher(m2);
+						matcher1.find();
+						matcher2.find();
+						if (!matcher1.group(1).equals(matcher2.group(1))) {
+							return m1.compareTo(m2);
+						}
+						else {
+							return Integer.valueOf(matcher1.group(2)).compareTo(Integer.valueOf(matcher2.group(2)));
+						}
+					});
+			return nextPreRelease.orElse(null);
+		}
+		catch (IOException e) {
+			throw new RuntimeException("Could not find open milestones with for repository " + repositoryRef, e);
+		}
+	}
+
+//	public boolean isOpenIssuesForMilestoneName(String owner, String repository, String milestoneName) {
+//
+//	}
+
+
+	private static class AuthorizationInterceptor implements Interceptor {
+
+		private final String token;
+
+		public AuthorizationInterceptor(String token) {
+			this.token = token;
+		}
+
+		@Override
+		public okhttp3.Response intercept(Chain chain) throws IOException {
+			Request request = chain.request().newBuilder()
+					.addHeader("Authorization", "Bearer " + this.token).build();
+			return chain.proceed(request);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/milestones/GitHubMilestoneHasNoOpenIssuesTask.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.gradle.github.milestones;
+
+import org.gradle.api.Action;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.work.DisableCachingByDefault;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.springframework.gradle.github.RepositoryRef;
+
+@DisableCachingByDefault(because = "the due date needs to be checked every time in case it changes")
+public abstract class GitHubMilestoneHasNoOpenIssuesTask extends DefaultTask {
+	@Input
+	private RepositoryRef repository = new RepositoryRef();
+
+	@Input @Optional
+	private String milestoneTitle;
+
+	@InputFile @Optional
+	public abstract RegularFileProperty getNextVersionFile();
+
+	@Input @Optional
+	private String gitHubAccessToken;
+
+	@OutputFile
+	public abstract RegularFileProperty getIsOpenIssuesFile();
+
+	private GitHubMilestoneApi milestones = new GitHubMilestoneApi();
+
+	@TaskAction
+	public void checkHasNoOpenIssues() throws IOException {
+		if (this.milestoneTitle == null) {
+			File nextVersionFile = getNextVersionFile().getAsFile().get();
+			Yaml yaml = new Yaml(new Constructor(NextVersionYml.class));
+			NextVersionYml nextVersionYml = yaml.load(new FileInputStream(nextVersionFile));
+			String nextVersion = nextVersionYml.getVersion();
+			if (nextVersion == null) {
+				throw new IllegalArgumentException(
+						"Could not find version property in provided file " + nextVersionFile.getName());
+			}
+			this.milestoneTitle = nextVersion;
+		}
+		long milestoneNumber = this.milestones.findMilestoneNumberByTitle(this.repository, this.milestoneTitle);
+		boolean isOpenIssues = this.milestones.isOpenIssuesForMilestoneNumber(this.repository, milestoneNumber);
+		Path isOpenIssuesPath = getIsOpenIssuesFile().getAsFile().get().toPath();
+		Files.writeString(isOpenIssuesPath, String.valueOf(isOpenIssues));
+		if (isOpenIssues) {
+			System.out.println("The repository " + this.repository + " has open issues for milestone with the title " + this.milestoneTitle + " and number " + milestoneNumber);
+		}
+		else {
+			System.out.println("The repository " + this.repository + " has no open issues for milestone with the title " + this.milestoneTitle + " and number " + milestoneNumber);
+		}
+	}
+
+	public RepositoryRef getRepository() {
+		return repository;
+	}
+
+	public void repository(Action<RepositoryRef> repository) {
+		repository.execute(this.repository);
+	}
+
+	public void setRepository(RepositoryRef repository) {
+		this.repository = repository;
+	}
+
+	public String getMilestoneTitle() {
+		return milestoneTitle;
+	}
+
+	public void setMilestoneTitle(String milestoneTitle) {
+		this.milestoneTitle = milestoneTitle;
+	}
+
+	public String getGitHubAccessToken() {
+		return gitHubAccessToken;
+	}
+
+	public void setGitHubAccessToken(String gitHubAccessToken) {
+		this.gitHubAccessToken = gitHubAccessToken;
+		this.milestones = new GitHubMilestoneApi(gitHubAccessToken);
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/milestones/GitHubMilestoneNextReleaseTask.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.milestones;
+
+import org.gradle.api.Action;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.nodes.Tag;
+import org.yaml.snakeyaml.representer.Representer;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import org.springframework.gradle.github.RepositoryRef;
+
+public abstract class GitHubMilestoneNextReleaseTask extends DefaultTask {
+
+	@Input
+	private RepositoryRef repository = new RepositoryRef();
+
+	@Input
+	@Optional
+	private String gitHubAccessToken;
+
+	private GitHubMilestoneApi milestones = new GitHubMilestoneApi();
+
+	@TaskAction
+	public void calculateNextReleaseMilestone() throws IOException {
+		String currentVersion = getProject().getVersion().toString();
+		String nextPreRelease = this.milestones.getNextReleaseMilestone(this.repository, currentVersion);
+		System.out.println("The next release milestone is: " + nextPreRelease);
+		NextVersionYml nextVersionYml = new NextVersionYml();
+		nextVersionYml.setVersion(nextPreRelease);
+		File outputFile = getNextReleaseFile().get().getAsFile();
+		FileWriter outputWriter = new FileWriter(outputFile);
+		Yaml yaml = getYaml();
+		yaml.dump(nextVersionYml, outputWriter);
+	}
+
+	@OutputFile
+	public abstract RegularFileProperty getNextReleaseFile();
+
+	public RepositoryRef getRepository() {
+		return repository;
+	}
+
+	public void repository(Action<RepositoryRef> repository) {
+		repository.execute(this.repository);
+	}
+
+	public void setRepository(RepositoryRef repository) {
+		this.repository = repository;
+	}
+
+	public String getGitHubAccessToken() {
+		return gitHubAccessToken;
+	}
+
+	public void setGitHubAccessToken(String gitHubAccessToken) {
+		this.gitHubAccessToken = gitHubAccessToken;
+		this.milestones = new GitHubMilestoneApi(gitHubAccessToken);
+	}
+
+	private Yaml getYaml() {
+		Representer representer = new Representer();
+		representer.addClassTag(NextVersionYml.class, Tag.MAP);
+		DumperOptions ymlOptions = new DumperOptions();
+		ymlOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+		return new Yaml(representer, ymlOptions);
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/github/milestones/GitHubMilestoneNextVersionDueTodayTask.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.milestones;
+
+import org.gradle.api.Action;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.work.DisableCachingByDefault;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.springframework.gradle.github.RepositoryRef;
+
+@DisableCachingByDefault(because = "the due date needs to be checked every time in case it changes")
+public abstract class GitHubMilestoneNextVersionDueTodayTask extends DefaultTask {
+
+	@Input
+	private RepositoryRef repository = new RepositoryRef();
+
+	@Input
+	@Optional
+	private String gitHubAccessToken;
+
+	@InputFile
+	public abstract RegularFileProperty getNextVersionFile();
+
+	@OutputFile
+	public abstract RegularFileProperty getIsDueTodayFile();
+
+	private GitHubMilestoneApi milestones = new GitHubMilestoneApi();
+
+	@TaskAction
+	public void checkReleaseDueToday() throws IOException {
+		File nextVersionFile = getNextVersionFile().getAsFile().get();
+		Yaml yaml = new Yaml(new Constructor(NextVersionYml.class));
+		NextVersionYml nextVersionYml = yaml.load(new FileInputStream(nextVersionFile));
+		String nextVersion = nextVersionYml.getVersion();
+		if (nextVersion == null) {
+			throw new IllegalArgumentException(
+					"Could not find version property in provided file " + nextVersionFile.getName());
+		}
+		boolean milestoneDueToday = this.milestones.isMilestoneDueToday(this.repository, nextVersion);
+		Path isDueTodayPath = getIsDueTodayFile().getAsFile().get().toPath();
+		Files.writeString(isDueTodayPath, String.valueOf(milestoneDueToday));
+		if (milestoneDueToday) {
+			System.out.println("The milestone with the title " + nextVersion + " in the repository " + this.repository
+					+ " is due today");
+		}
+		else {
+			System.out.println("The milestone with the title " + nextVersion + " in the repository "
+					+ this.repository + " is not due yet");
+		}
+
+	}
+
+	public RepositoryRef getRepository() {
+		return repository;
+	}
+
+	public void repository(Action<RepositoryRef> repository) {
+		repository.execute(this.repository);
+	}
+
+	public void setRepository(RepositoryRef repository) {
+		this.repository = repository;
+	}
+
+	public String getGitHubAccessToken() {
+		return gitHubAccessToken;
+	}
+
+	public void setGitHubAccessToken(String gitHubAccessToken) {
+		this.gitHubAccessToken = gitHubAccessToken;
+		this.milestones = new GitHubMilestoneApi(gitHubAccessToken);
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/github/milestones/GitHubMilestonePlugin.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.milestones;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.TaskProvider;
+
+public class GitHubMilestonePlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		TaskProvider<GitHubMilestoneNextReleaseTask> nextReleaseMilestoneTask = project.getTasks().register("gitHubNextReleaseMilestone", GitHubMilestoneNextReleaseTask.class, new Action<GitHubMilestoneNextReleaseTask>() {
+					@Override
+					public void execute(GitHubMilestoneNextReleaseTask gitHubMilestoneNextReleaseTask) {
+						gitHubMilestoneNextReleaseTask.doNotTrackState("API call to GitHub needs to check for new milestones every time");
+						gitHubMilestoneNextReleaseTask.setGroup("Release");
+						gitHubMilestoneNextReleaseTask.setDescription("Calculates the next release version based on the current version and outputs it to a yaml file");
+						gitHubMilestoneNextReleaseTask.getNextReleaseFile()
+								.fileProvider(project.provider(() -> project.file("next-release.yml")));
+						if (project.hasProperty("gitHubAccessToken")) {
+							gitHubMilestoneNextReleaseTask
+									.setGitHubAccessToken((String) project.findProperty("gitHubAccessToken"));
+						}
+					}
+				});
+		project.getTasks().register("gitHubCheckMilestoneHasNoOpenIssues", GitHubMilestoneHasNoOpenIssuesTask.class, new Action<GitHubMilestoneHasNoOpenIssuesTask>() {
+			@Override
+			public void execute(GitHubMilestoneHasNoOpenIssuesTask githubCheckMilestoneHasNoOpenIssues) {
+				githubCheckMilestoneHasNoOpenIssues.setGroup("Release");
+				githubCheckMilestoneHasNoOpenIssues.setDescription("Checks if there are any open issues for the specified repository and milestone");
+				githubCheckMilestoneHasNoOpenIssues.getIsOpenIssuesFile().value(project.getLayout().getBuildDirectory().file("github/milestones/is-open-issues"));
+				githubCheckMilestoneHasNoOpenIssues.setMilestoneTitle((String) project.findProperty("nextVersion"));
+				if (!project.hasProperty("nextVersion")) {
+					githubCheckMilestoneHasNoOpenIssues.getNextVersionFile().convention(
+							nextReleaseMilestoneTask.flatMap(GitHubMilestoneNextReleaseTask::getNextReleaseFile));
+				}
+				if (project.hasProperty("gitHubAccessToken")) {
+					githubCheckMilestoneHasNoOpenIssues.setGitHubAccessToken((String) project.findProperty("gitHubAccessToken"));
+				}
+			}
+		});
+		project.getTasks().register("gitHubCheckNextVersionDueToday", GitHubMilestoneNextVersionDueTodayTask.class, new Action<GitHubMilestoneNextVersionDueTodayTask>() {
+					@Override
+					public void execute(GitHubMilestoneNextVersionDueTodayTask gitHubMilestoneNextVersionDueTodayTask) {
+						gitHubMilestoneNextVersionDueTodayTask.setGroup("Release");
+						gitHubMilestoneNextVersionDueTodayTask.setDescription("Checks if the next release version is due today or past due, will fail if the next version is not due yet");
+						gitHubMilestoneNextVersionDueTodayTask.getIsDueTodayFile().value(project.getLayout().getBuildDirectory().file("github/milestones/is-due-today"));
+						gitHubMilestoneNextVersionDueTodayTask.getNextVersionFile().convention(
+								nextReleaseMilestoneTask.flatMap(GitHubMilestoneNextReleaseTask::getNextReleaseFile));
+						if (project.hasProperty("gitHubAccessToken")) {
+							gitHubMilestoneNextVersionDueTodayTask
+									.setGitHubAccessToken((String) project.findProperty("gitHubAccessToken"));
+						}
+					}
+				});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/milestones/Milestone.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.milestones;
+
+import com.google.gson.annotations.SerializedName;
+
+import java.util.Date;
+
+public class Milestone {
+	private String title;
+
+	private long number;
+
+	@SerializedName("due_on")
+	private Date dueOn;
+
+	public String getTitle() {
+		return title;
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	public long getNumber() {
+		return number;
+	}
+
+	public void setNumber(long number) {
+		this.number = number;
+	}
+
+	public Date getDueOn() {
+		return dueOn;
+	}
+
+	public void setDueOn(Date dueOn) {
+		this.dueOn = dueOn;
+	}
+
+	@Override
+	public String toString() {
+		return "Milestone{" +
+				"title='" + title + '\'' +
+				", number='" + number + '\'' +
+				", dueOn='" + dueOn +
+				'}';
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/milestones/NextVersionYml.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.milestones;
+
+public class NextVersionYml {
+	private String version;
+
+	public String getVersion() {
+		return version;
+	}
+
+	public void setVersion(String version) {
+		this.version = version;
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/release/CreateGitHubReleaseTask.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.release;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import org.gradle.api.Action;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.TaskAction;
+
+import org.springframework.gradle.github.RepositoryRef;
+import org.springframework.gradle.github.changelog.GitHubChangelogPlugin;
+
+/**
+ * @author Steve Riesenberg
+ */
+public class CreateGitHubReleaseTask extends DefaultTask {
+	@Input
+	private RepositoryRef repository = new RepositoryRef();
+
+	@Input @Optional
+	private String gitHubAccessToken;
+
+	@Input
+	private String version;
+
+	@Input @Optional
+	private String branch = "main";
+
+	@Input
+	private boolean createRelease = false;
+
+	@TaskAction
+	public void createGitHubRelease() {
+		String body = readReleaseNotes();
+		Release release = Release.tag(this.version)
+				.commit(this.branch)
+				.name(this.version)
+				.body(body)
+				.preRelease(this.version.contains("-"))
+				.build();
+
+		System.out.printf("%sCreating GitHub release for %s/%s@%s\n",
+				this.createRelease ? "" : "[DRY RUN] ",
+				this.repository.getOwner(),
+				this.repository.getName(),
+				this.version
+		);
+		System.out.printf("  Release Notes:\n\n----\n%s\n----\n\n", body.trim());
+
+		if (this.createRelease) {
+			GitHubReleaseApi github = new GitHubReleaseApi(this.gitHubAccessToken);
+			github.publishRelease(this.repository, release);
+		}
+	}
+
+	private String readReleaseNotes() {
+		Project project = getProject();
+		File inputFile = project.file(Paths.get(project.getBuildDir().getPath(), GitHubChangelogPlugin.RELEASE_NOTES_PATH));
+		try {
+			return Files.readString(inputFile.toPath());
+		} catch (IOException ex) {
+			throw new RuntimeException("Unable to read release notes from " + inputFile, ex);
+		}
+	}
+
+	public RepositoryRef getRepository() {
+		return repository;
+	}
+
+	public void repository(Action<RepositoryRef> repository) {
+		repository.execute(this.repository);
+	}
+
+	public void setRepository(RepositoryRef repository) {
+		this.repository = repository;
+	}
+
+	public String getGitHubAccessToken() {
+		return gitHubAccessToken;
+	}
+
+	public void setGitHubAccessToken(String gitHubAccessToken) {
+		this.gitHubAccessToken = gitHubAccessToken;
+	}
+
+	public String getVersion() {
+		return version;
+	}
+
+	public void setVersion(String version) {
+		this.version = version;
+	}
+
+	public String getBranch() {
+		return branch;
+	}
+
+	public void setBranch(String branch) {
+		this.branch = branch;
+	}
+
+	public boolean isCreateRelease() {
+		return createRelease;
+	}
+
+	public void setCreateRelease(boolean createRelease) {
+		this.createRelease = createRelease;
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/release/GitHubReleaseApi.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.release;
+
+import java.io.IOException;
+
+import com.google.gson.Gson;
+import okhttp3.Interceptor;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+import org.springframework.gradle.github.RepositoryRef;
+
+/**
+ * Manage GitHub releases.
+ *
+ * @author Steve Riesenberg
+ */
+public class GitHubReleaseApi {
+	private String baseUrl = "https://api.github.com";
+
+	private final OkHttpClient httpClient;
+	private Gson gson = new Gson();
+
+	public GitHubReleaseApi(String gitHubAccessToken) {
+		this.httpClient = new OkHttpClient.Builder()
+				.addInterceptor(new AuthorizationInterceptor(gitHubAccessToken))
+				.build();
+	}
+
+	public void setBaseUrl(String baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+
+	/**
+	 * Publish a release with no binary attachments.
+	 *
+	 * @param repository The repository owner/name
+	 * @param release The contents of the release
+	 */
+	public void publishRelease(RepositoryRef repository, Release release) {
+		String url = this.baseUrl + "/repos/" + repository.getOwner() + "/" + repository.getName() + "/releases";
+		String json = this.gson.toJson(release);
+		RequestBody body = RequestBody.create(MediaType.parse("application/json"), json);
+		Request request = new Request.Builder().url(url).post(body).build();
+		try {
+			Response response = this.httpClient.newCall(request).execute();
+			if (!response.isSuccessful()) {
+				throw new RuntimeException(String.format("Could not create release %s for repository %s/%s. Got response %s",
+						release.getName(), repository.getOwner(), repository.getName(), response));
+			}
+		} catch (IOException ex) {
+			throw new RuntimeException(String.format("Could not create release %s for repository %s/%s",
+					release.getName(), repository.getOwner(), repository.getName()), ex);
+		}
+	}
+
+	private static class AuthorizationInterceptor implements Interceptor {
+		private final String token;
+
+		public AuthorizationInterceptor(String token) {
+			this.token = token;
+		}
+
+		@Override
+		public Response intercept(Chain chain) throws IOException {
+			Request request = chain.request().newBuilder()
+					.addHeader("Authorization", "Bearer " + this.token)
+					.build();
+
+			return chain.proceed(request);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/release/GitHubReleasePlugin.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.release;
+
+import groovy.lang.MissingPropertyException;
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+/**
+ * @author Steve Riesenberg
+ */
+public class GitHubReleasePlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getTasks().register("createGitHubRelease", CreateGitHubReleaseTask.class, new Action<CreateGitHubReleaseTask>() {
+			@Override
+			public void execute(CreateGitHubReleaseTask createGitHubRelease) {
+				createGitHubRelease.setGroup("Release");
+				createGitHubRelease.setDescription("Create a github release");
+				createGitHubRelease.dependsOn("generateChangelog");
+
+				createGitHubRelease.setCreateRelease("true".equals(project.findProperty("createRelease")));
+				createGitHubRelease.setVersion((String) project.findProperty("nextVersion"));
+				if (project.hasProperty("branch")) {
+					createGitHubRelease.setBranch((String) project.findProperty("branch"));
+				}
+				createGitHubRelease.setGitHubAccessToken((String) project.findProperty("gitHubAccessToken"));
+				if (createGitHubRelease.isCreateRelease() && createGitHubRelease.getGitHubAccessToken() == null) {
+					throw new MissingPropertyException("Please provide an access token with -PgitHubAccessToken=...");
+				}
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/github/release/Release.java

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.github.release;
+
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * @author Steve Riesenberg
+ */
+public class Release {
+	@SerializedName("tag_name")
+	private final String tag;
+
+	@SerializedName("target_commitish")
+	private final String commit;
+
+	@SerializedName("name")
+	private final String name;
+
+	@SerializedName("body")
+	private final String body;
+
+	@SerializedName("draft")
+	private final boolean draft;
+
+	@SerializedName("prerelease")
+	private final boolean preRelease;
+
+	@SerializedName("generate_release_notes")
+	private final boolean generateReleaseNotes;
+
+	private Release(String tag, String commit, String name, String body, boolean draft, boolean preRelease, boolean generateReleaseNotes) {
+		this.tag = tag;
+		this.commit = commit;
+		this.name = name;
+		this.body = body;
+		this.draft = draft;
+		this.preRelease = preRelease;
+		this.generateReleaseNotes = generateReleaseNotes;
+	}
+
+	public String getTag() {
+		return tag;
+	}
+
+	public String getCommit() {
+		return commit;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public String getBody() {
+		return body;
+	}
+
+	public boolean isDraft() {
+		return draft;
+	}
+
+	public boolean isPreRelease() {
+		return preRelease;
+	}
+
+	public boolean isGenerateReleaseNotes() {
+		return generateReleaseNotes;
+	}
+
+	@Override
+	public String toString() {
+		return "Release{" +
+				"tag='" + tag + '\'' +
+				", commit='" + commit + '\'' +
+				", name='" + name + '\'' +
+				", body='" + body + '\'' +
+				", draft=" + draft +
+				", preRelease=" + preRelease +
+				", generateReleaseNotes=" + generateReleaseNotes +
+				'}';
+	}
+
+	public static Builder tag(String tag) {
+		return new Builder().tag(tag);
+	}
+
+	public static Builder commit(String commit) {
+		return new Builder().commit(commit);
+	}
+
+	public static final class Builder {
+		private String tag;
+		private String commit;
+		private String name;
+		private String body;
+		private boolean draft;
+		private boolean preRelease;
+		private boolean generateReleaseNotes;
+
+		private Builder() {
+		}
+
+		public Builder tag(String tag) {
+			this.tag = tag;
+			return this;
+		}
+
+		public Builder commit(String commit) {
+			this.commit = commit;
+			return this;
+		}
+
+		public Builder name(String name) {
+			this.name = name;
+			return this;
+		}
+
+		public Builder body(String body) {
+			this.body = body;
+			return this;
+		}
+
+		public Builder draft(boolean draft) {
+			this.draft = draft;
+			return this;
+		}
+
+		public Builder preRelease(boolean preRelease) {
+			this.preRelease = preRelease;
+			return this;
+		}
+
+		public Builder generateReleaseNotes(boolean generateReleaseNotes) {
+			this.generateReleaseNotes = generateReleaseNotes;
+			return this;
+		}
+
+		public Release build() {
+			return new Release(tag, commit, name, body, draft, preRelease, generateReleaseNotes);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/maven/MavenPublishingConventionsPlugin.java

@@ -0,0 +1,82 @@
+package org.springframework.gradle.maven;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaPluginExtension;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.maven.MavenPom;
+import org.gradle.api.publish.maven.MavenPomDeveloperSpec;
+import org.gradle.api.publish.maven.MavenPomIssueManagement;
+import org.gradle.api.publish.maven.MavenPomLicenseSpec;
+import org.gradle.api.publish.maven.MavenPomOrganization;
+import org.gradle.api.publish.maven.MavenPomScm;
+import org.gradle.api.publish.maven.MavenPublication;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+public class MavenPublishingConventionsPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().withType(MavenPublishPlugin.class).all(new Action<MavenPublishPlugin>() {
+			@Override
+			public void execute(MavenPublishPlugin mavenPublish) {
+				PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
+				publishing.getPublications().withType(MavenPublication.class)
+						.all((mavenPublication) -> MavenPublishingConventionsPlugin.this.customizePom(mavenPublication.getPom(), project));
+				MavenPublishingConventionsPlugin.this.customizeJavaPlugin(project);
+			}
+		});
+	}
+
+	private void customizePom(MavenPom pom, Project project) {
+		pom.getUrl().set("https://spring.io/projects/spring-security");
+		pom.getName().set(project.provider(project::getName));
+		pom.getDescription().set(project.provider(project::getDescription));
+		pom.organization(this::customizeOrganization);
+		pom.licenses(this::customizeLicences);
+		pom.developers(this::customizeDevelopers);
+		pom.scm(this::customizeScm);
+		pom.issueManagement(this::customizeIssueManagement);
+	}
+
+	private void customizeOrganization(MavenPomOrganization organization) {
+		organization.getName().set("Pivotal Software, Inc.");
+		organization.getUrl().set("https://spring.io");
+	}
+
+	private void customizeLicences(MavenPomLicenseSpec licences) {
+		licences.license((licence) -> {
+			licence.getName().set("Apache License, Version 2.0");
+			licence.getUrl().set("https://www.apache.org/licenses/LICENSE-2.0");
+		});
+	}
+
+	private void customizeDevelopers(MavenPomDeveloperSpec developers) {
+		developers.developer((developer) -> {
+			developer.getName().set("Pivotal");
+			developer.getEmail().set("info@pivotal.io");
+			developer.getOrganization().set("Pivotal Software, Inc.");
+			developer.getOrganizationUrl().set("https://www.spring.io");
+		});
+	}
+
+	private void customizeScm(MavenPomScm scm) {
+		scm.getConnection().set("scm:git:git://github.com/spring-projects/spring-security.git");
+		scm.getDeveloperConnection().set("scm:git:ssh://git@github.com/spring-projects/spring-security.git");
+		scm.getUrl().set("https://github.com/spring-projects/spring-security");
+	}
+
+	private void customizeIssueManagement(MavenPomIssueManagement issueManagement) {
+		issueManagement.getSystem().set("GitHub");
+		issueManagement.getUrl().set("https://github.com/spring-projects/spring-security/issues");
+	}
+
+	private void customizeJavaPlugin(Project project) {
+		project.getPlugins().withType(JavaPlugin.class).all((javaPlugin) -> {
+			JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
+			extension.withJavadocJar();
+			extension.withSourcesJar();
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/maven/PublishAllJavaComponentsPlugin.java

@@ -0,0 +1,33 @@
+package org.springframework.gradle.maven;
+
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlatformPlugin;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.VariantVersionMappingStrategy;
+import org.gradle.api.publish.VersionMappingStrategy;
+import org.gradle.api.publish.maven.MavenPublication;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+public class PublishAllJavaComponentsPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().withType(MavenPublishPlugin.class).all((mavenPublish) -> {
+			PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
+			publishing.getPublications().create("mavenJava", MavenPublication.class, new Action<MavenPublication>() {
+				@Override
+				public void execute(MavenPublication maven) {
+					project.getPlugins().withType(JavaPlugin.class, (plugin) -> {
+						maven.from(project.getComponents().getByName("java"));
+					});
+					project.getPlugins().withType(JavaPlatformPlugin.class, (plugin) -> {
+						maven.from(project.getComponents().getByName("javaPlatform"));
+					});
+				}
+			});
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/maven/PublishArtifactsPlugin.java

@@ -0,0 +1,26 @@
+package org.springframework.gradle.maven;
+
+import io.spring.gradle.convention.Utils;
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.Task;
+
+public class PublishArtifactsPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getTasks().register("publishArtifacts", new Action<Task>() {
+			@Override
+			public void execute(Task publishArtifacts) {
+				publishArtifacts.setGroup("Publishing");
+				publishArtifacts.setDescription("Publish the artifacts to either Artifactory or Maven Central based on the version");
+				if (Utils.isRelease(project)) {
+					publishArtifacts.dependsOn("publishToOssrh");
+				}
+				else {
+					publishArtifacts.dependsOn("artifactoryPublish");
+				}
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/maven/PublishLocalPlugin.java

@@ -0,0 +1,29 @@
+package org.springframework.gradle.maven;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.repositories.MavenArtifactRepository;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+import java.io.File;
+
+public class PublishLocalPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().withType(MavenPublishPlugin.class).all(new Action<MavenPublishPlugin>() {
+			@Override
+			public void execute(MavenPublishPlugin mavenPublish) {
+				PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
+				publishing.getRepositories().maven(new Action<MavenArtifactRepository>() {
+					@Override
+					public void execute(MavenArtifactRepository maven) {
+						maven.setName("local");
+						maven.setUrl(new File(project.getRootProject().getBuildDir(), "publications/repos"));
+					}
+				});
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/maven/SpringMavenPlugin.java

@@ -0,0 +1,21 @@
+package org.springframework.gradle.maven;
+
+import io.spring.gradle.convention.ArtifactoryPlugin;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.PluginManager;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+public class SpringMavenPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(MavenPublishPlugin.class);
+		pluginManager.apply(SpringSigningPlugin.class);
+		pluginManager.apply(MavenPublishingConventionsPlugin.class);
+		pluginManager.apply(PublishAllJavaComponentsPlugin.class);
+		pluginManager.apply(PublishLocalPlugin.class);
+		pluginManager.apply(PublishArtifactsPlugin.class);
+		pluginManager.apply(ArtifactoryPlugin.class);
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/maven/SpringNexusPublishPlugin.java

@@ -0,0 +1,28 @@
+package org.springframework.gradle.maven;
+
+import io.github.gradlenexus.publishplugin.NexusPublishExtension;
+import io.github.gradlenexus.publishplugin.NexusPublishPlugin;
+import io.github.gradlenexus.publishplugin.NexusRepository;
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+import java.net.URI;
+import java.time.Duration;
+
+public class SpringNexusPublishPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().apply(NexusPublishPlugin.class);
+		NexusPublishExtension nexusPublishing = project.getExtensions().findByType(NexusPublishExtension.class);
+		nexusPublishing.getRepositories().create("ossrh", new Action<NexusRepository>() {
+			@Override
+			public void execute(NexusRepository nexusRepository) {
+						nexusRepository.getNexusUrl().set(URI.create("https://s01.oss.sonatype.org/service/local/"));
+						nexusRepository.getSnapshotRepositoryUrl().set(URI.create("https://s01.oss.sonatype.org/content/repositories/snapshots/"));
+					}
+		});
+		nexusPublishing.getConnectTimeout().set(Duration.ofMinutes(3));
+		nexusPublishing.getClientTimeout().set(Duration.ofMinutes(3));
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/maven/SpringSigningPlugin.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2016-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.springframework.gradle.maven;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.publish.Publication;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.plugins.PublishingPlugin;
+import org.gradle.plugins.signing.SigningExtension;
+import org.gradle.plugins.signing.SigningPlugin;
+
+import java.util.concurrent.Callable;
+
+public class SpringSigningPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getPluginManager().apply(SigningPlugin.class);
+		project.getPlugins().withType(SigningPlugin.class).all(new Action<SigningPlugin>() {
+			@Override
+			public void execute(SigningPlugin signingPlugin) {
+				boolean hasSigningKey = project.hasProperty("signing.keyId") || project.hasProperty("signingKey");
+				if (hasSigningKey) {
+					sign(project);
+				}
+			}
+		});
+	}
+
+	private void sign(Project project) {
+		SigningExtension signing = project.getExtensions().findByType(SigningExtension.class);
+		signing.setRequired(new Callable<Boolean>() {
+			@Override
+			public Boolean call() throws Exception {
+				return project.getGradle().getTaskGraph().hasTask("publishArtifacts");
+			}
+		});
+		String signingKeyId = (String) project.findProperty("signingKeyId");
+		String signingKey = (String) project.findProperty("signingKey");
+		String signingPassword = (String) project.findProperty("signingPassword");
+		if (signingKeyId != null) {
+			signing.useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword);
+		} else {
+			signing.useInMemoryPgpKeys(signingKey, signingPassword);
+		}
+		project.getPlugins().withType(PublishAllJavaComponentsPlugin.class).all(new Action<PublishAllJavaComponentsPlugin>() {
+			@Override
+			public void execute(PublishAllJavaComponentsPlugin publishingPlugin) {
+				PublishingExtension publishing = project.getExtensions().findByType(PublishingExtension.class);
+				Publication maven = publishing.getPublications().getByName("mavenJava");
+				signing.sign(maven);
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/propdeps/PropDepsEclipsePlugin.groovy

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.propdeps
+
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.plugins.ide.eclipse.EclipsePlugin
+
+/**
+ * Plugin to allow optional and provided dependency configurations to work with the
+ * standard gradle 'eclipse' plugin
+ *
+ * @author Phillip Webb
+ */
+class PropDepsEclipsePlugin implements Plugin<Project> {
+
+	public void apply(Project project) {
+		project.plugins.apply(PropDepsPlugin)
+		project.plugins.apply(EclipsePlugin)
+
+		project.eclipse {
+			classpath {
+				plusConfigurations += [project.configurations.provided, project.configurations.optional]
+			}
+		}
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/propdeps/PropDepsIdeaPlugin.groovy

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.propdeps
+
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.plugins.ide.idea.IdeaPlugin
+
+/**
+ * Plugin to allow optional and provided dependency configurations to work with the
+ * standard gradle 'idea' plugin
+ *
+ * @author Phillip Webb
+ * @author Brian Clozel
+ * @link https://youtrack.jetbrains.com/issue/IDEA-107046
+ * @link https://youtrack.jetbrains.com/issue/IDEA-117668
+ */
+class PropDepsIdeaPlugin implements Plugin<Project> {
+
+	public void apply(Project project) {
+		project.plugins.apply(PropDepsPlugin)
+		project.plugins.apply(IdeaPlugin)
+		project.idea.module {
+			// IDEA internally deals with 4 scopes : COMPILE, TEST, PROVIDED, RUNTIME
+			// but only PROVIDED seems to be picked up
+			scopes.PROVIDED.plus += [project.configurations.provided]
+			scopes.PROVIDED.plus += [project.configurations.optional]
+		}
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/propdeps/PropDepsPlugin.groovy

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.propdeps
+
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.plugins.JavaLibraryPlugin
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.tasks.javadoc.Javadoc
+
+/**
+ * Plugin to allow 'optional' and 'provided' dependency configurations
+ *
+ * As stated in the maven documentation, provided scope "is only available on the compilation and test classpath,
+ * and is not transitive".
+ *
+ * This plugin creates two new configurations, and each one:
+ * <ul>
+ * <li>is a parent of the compile configuration</li>
+ * <li>is not visible, not transitive</li>
+ * <li>all dependencies are excluded from the default configuration</li>
+ * </ul>
+ *
+ * @author Phillip Webb
+ * @author Brian Clozel
+ * @author Rob Winch
+ *
+ * @see <a href="https://www.gradle.org/docs/current/userguide/java_plugin.html#N121CF">Maven documentation</a>
+ * @see <a href="https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Dependency_Scope">Gradle configurations</a>
+ * @see PropDepsEclipsePlugin
+ * @see PropDepsIdeaPlugin
+ */
+class PropDepsPlugin implements Plugin<Project> {
+
+	public void apply(Project project) {
+		project.plugins.apply(JavaPlugin)
+
+		Configuration provided = addConfiguration(project, "provided")
+		Configuration optional = addConfiguration(project, "optional")
+
+		Javadoc javadoc = project.tasks.getByName(JavaPlugin.JAVADOC_TASK_NAME)
+		javadoc.classpath = javadoc.classpath.plus(provided).plus(optional)
+	}
+
+	private Configuration addConfiguration(Project project, String name) {
+		Configuration configuration = project.configurations.create(name)
+		configuration.extendsFrom(project.configurations.implementation)
+		project.plugins.withType(JavaLibraryPlugin, {
+			configuration.extendsFrom(project.configurations.api)
+		})
+
+		project.sourceSets.all {
+			compileClasspath += configuration
+			runtimeClasspath += configuration
+		}
+
+		return configuration
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/sagan/Release.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.sagan;
+
+import java.util.regex.Pattern;
+
+/**
+ * Domain object for creating a new release version.
+ */
+public class Release {
+	private String version;
+
+	private ReleaseStatus status;
+
+	private boolean current;
+
+	private String referenceDocUrl;
+
+	private String apiDocUrl;
+
+	public String getVersion() {
+		return version;
+	}
+
+	public void setVersion(String version) {
+		this.version = version;
+	}
+
+	public ReleaseStatus getStatus() {
+		return status;
+	}
+
+	public void setStatus(ReleaseStatus status) {
+		this.status = status;
+	}
+
+	public boolean isCurrent() {
+		return current;
+	}
+
+	public void setCurrent(boolean current) {
+		this.current = current;
+	}
+
+	public String getReferenceDocUrl() {
+		return referenceDocUrl;
+	}
+
+	public void setReferenceDocUrl(String referenceDocUrl) {
+		this.referenceDocUrl = referenceDocUrl;
+	}
+
+	public String getApiDocUrl() {
+		return apiDocUrl;
+	}
+
+	public void setApiDocUrl(String apiDocUrl) {
+		this.apiDocUrl = apiDocUrl;
+	}
+
+	@Override
+	public String toString() {
+		return "Release{" +
+				"version='" + version + '\'' +
+				", status=" + status +
+				", current=" + current +
+				", referenceDocUrl='" + referenceDocUrl + '\'' +
+				", apiDocUrl='" + apiDocUrl + '\'' +
+				'}';
+	}
+
+	public enum ReleaseStatus {
+		/**
+		 * Unstable version with limited support
+		 */
+		SNAPSHOT,
+		/**
+		 * Pre-Release version meant to be tested by the community
+		 */
+		PRERELEASE,
+		/**
+		 * Release Generally Available on public artifact repositories and enjoying full support from maintainers
+		 */
+		GENERAL_AVAILABILITY;
+
+		private static final Pattern PRERELEASE_PATTERN = Pattern.compile("[A-Za-z0-9\\.\\-]+?(M|RC)\\d+");
+
+		private static final String SNAPSHOT_SUFFIX = "SNAPSHOT";
+
+		/**
+		 * Parse the ReleaseStatus from a String
+		 * @param version a project version
+		 * @return the release status for this version
+		 */
+		public static ReleaseStatus parse(String version) {
+			if (version == null) {
+				throw new IllegalArgumentException("version cannot be null");
+			}
+			if (version.endsWith(SNAPSHOT_SUFFIX)) {
+				return SNAPSHOT;
+			}
+			if (PRERELEASE_PATTERN.matcher(version).matches()) {
+				return PRERELEASE;
+			}
+			return GENERAL_AVAILABILITY;
+		}
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/sagan/SaganApi.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.sagan;
+
+import com.google.gson.Gson;
+import okhttp3.*;
+
+import java.io.IOException;
+import java.util.Base64;
+
+/**
+ * Implements necessary calls to the Sagan API See https://spring.io/restdocs/index.html
+ */
+public class SaganApi {
+	private String baseUrl = "https://spring.io/api";
+
+	private OkHttpClient client;
+	private Gson gson = new Gson();
+
+	public SaganApi(String gitHubToken) {
+		this.client = new OkHttpClient.Builder()
+				.addInterceptor(new BasicInterceptor("not-used", gitHubToken))
+				.build();
+	}
+
+	public void setBaseUrl(String baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+
+	public void createReleaseForProject(Release release, String projectName) {
+		String url = this.baseUrl + "/projects/" + projectName + "/releases";
+		String releaseJsonString = gson.toJson(release);
+		RequestBody body = RequestBody.create(MediaType.parse("application/json"), releaseJsonString);
+		Request request = new Request.Builder()
+			.url(url)
+			.post(body)
+			.build();
+		try {
+			Response response = this.client.newCall(request).execute();
+			if (!response.isSuccessful()) {
+				throw new RuntimeException("Could not create release " + release + ". Got response " + response);
+			}
+		} catch (IOException fail) {
+			throw new RuntimeException("Could not create release " + release, fail);
+		}
+	}
+
+	public void deleteReleaseForProject(String release, String projectName) {
+		String url = this.baseUrl + "/projects/" + projectName + "/releases/" + release;
+		Request request = new Request.Builder()
+				.url(url)
+				.delete()
+				.build();
+		try {
+			Response response = this.client.newCall(request).execute();
+			if (!response.isSuccessful()) {
+				throw new RuntimeException("Could not delete release " + release + ". Got response " + response);
+			}
+		} catch (IOException fail) {
+			throw new RuntimeException("Could not delete release " + release, fail);
+		}
+	}
+
+	private static class BasicInterceptor implements Interceptor {
+
+		private final String token;
+
+		public BasicInterceptor(String username, String token) {
+			this.token = Base64.getEncoder().encodeToString((username + ":" + token).getBytes());
+		}
+
+		@Override
+		public okhttp3.Response intercept(Chain chain) throws IOException {
+			Request request = chain.request().newBuilder()
+					.addHeader("Authorization", "Basic " + this.token).build();
+			return chain.proceed(request);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/gradle/sagan/SaganCreateReleaseTask.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.sagan;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.TaskAction;
+
+public class SaganCreateReleaseTask extends DefaultTask {
+
+	@Input
+	private String gitHubAccessToken;
+	@Input
+	private String version;
+	@Input
+	private String apiDocUrl;
+	@Input
+	private String referenceDocUrl;
+	@Input
+	private String projectName;
+
+	@TaskAction
+	public void saganCreateRelease() {
+		SaganApi sagan = new SaganApi(this.gitHubAccessToken);
+		Release release = new Release();
+		release.setVersion(this.version);
+		release.setApiDocUrl(this.apiDocUrl);
+		release.setReferenceDocUrl(this.referenceDocUrl);
+		sagan.createReleaseForProject(release, this.projectName);
+	}
+
+	public String getGitHubAccessToken() {
+		return gitHubAccessToken;
+	}
+
+	public void setGitHubAccessToken(String gitHubAccessToken) {
+		this.gitHubAccessToken = gitHubAccessToken;
+	}
+
+	public String getVersion() {
+		return version;
+	}
+
+	public void setVersion(String version) {
+		this.version = version;
+	}
+
+	public String getApiDocUrl() {
+		return apiDocUrl;
+	}
+
+	public void setApiDocUrl(String apiDocUrl) {
+		this.apiDocUrl = apiDocUrl;
+	}
+
+	public String getReferenceDocUrl() {
+		return referenceDocUrl;
+	}
+
+	public void setReferenceDocUrl(String referenceDocUrl) {
+		this.referenceDocUrl = referenceDocUrl;
+	}
+
+	public String getProjectName() {
+		return projectName;
+	}
+
+	public void setProjectName(String projectName) {
+		this.projectName = projectName;
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/sagan/SaganDeleteReleaseTask.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.sagan;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.TaskAction;
+
+public class SaganDeleteReleaseTask extends DefaultTask {
+
+	@Input
+	private String gitHubAccessToken;
+	@Input
+	private String version;
+	@Input
+	private String projectName;
+
+	@TaskAction
+	public void saganCreateRelease() {
+		SaganApi sagan = new SaganApi(this.gitHubAccessToken);
+		sagan.deleteReleaseForProject(this.version, this.projectName);
+	}
+
+	public String getGitHubAccessToken() {
+		return gitHubAccessToken;
+	}
+
+	public void setGitHubAccessToken(String gitHubAccessToken) {
+		this.gitHubAccessToken = gitHubAccessToken;
+	}
+
+	public String getVersion() {
+		return version;
+	}
+
+	public void setVersion(String version) {
+		this.version = version;
+	}
+
+	public String getProjectName() {
+		return projectName;
+	}
+
+	public void setProjectName(String projectName) {
+		this.projectName = projectName;
+	}
+
+}

buildSrc/src/main/java/org/springframework/gradle/sagan/SaganPlugin.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.gradle.sagan;
+
+import io.spring.gradle.convention.Utils;
+import org.gradle.api.*;
+
+public class SaganPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getTasks().register("saganCreateRelease", SaganCreateReleaseTask.class, new Action<SaganCreateReleaseTask>() {
+			@Override
+			public void execute(SaganCreateReleaseTask saganCreateVersion) {
+				saganCreateVersion.setGroup("Release");
+				saganCreateVersion.setDescription("Creates a new version for the specified project on spring.io");
+				saganCreateVersion.setVersion((String) project.findProperty("nextVersion"));
+				saganCreateVersion.setProjectName(Utils.getProjectName(project));
+				saganCreateVersion.setGitHubAccessToken((String) project.findProperty("gitHubAccessToken"));
+			}
+		});
+		project.getTasks().register("saganDeleteRelease", SaganDeleteReleaseTask.class, new Action<SaganDeleteReleaseTask>() {
+			@Override
+			public void execute(SaganDeleteReleaseTask saganDeleteVersion) {
+				saganDeleteVersion.setGroup("Release");
+				saganDeleteVersion.setDescription("Delete a version for the specified project on spring.io");
+				saganDeleteVersion.setVersion((String) project.findProperty("previousVersion"));
+				saganDeleteVersion.setProjectName(Utils.getProjectName(project));
+				saganDeleteVersion.setGitHubAccessToken((String) project.findProperty("gitHubAccessToken"));
+			}
+		});
+	}
+
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/CommandLineUtils.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.convention.versions;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Scanner;
+
+class CommandLineUtils {
+	static void runCommand(File dir, String... args) {
+		try {
+			Process process = new ProcessBuilder()
+					.directory(dir)
+					.command(args)
+					.start();
+			writeLinesTo(process.getInputStream(), System.out);
+			writeLinesTo(process.getErrorStream(), System.out);
+			if (process.waitFor() != 0) {
+				new RuntimeException("Failed to run " + Arrays.toString(args));
+			}
+		} catch (IOException | InterruptedException e) {
+			throw new RuntimeException("Failed to run " + Arrays.toString(args), e);
+		}
+	}
+
+	private static void writeLinesTo(InputStream input, PrintStream out) {
+		Scanner scanner = new Scanner(input);
+		while(scanner.hasNextLine()) {
+			out.println(scanner.nextLine());
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/FileUtils.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.convention.versions;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.function.Function;
+
+class FileUtils {
+	static void replaceFileText(File file, Function<String, String> replaceText) {
+		String buildFileText = readString(file);
+		String updatedBuildFileText = replaceText.apply(buildFileText);
+		writeString(file, updatedBuildFileText);
+	}
+
+	static String readString(File file) {
+		try {
+			byte[] bytes = Files.readAllBytes(file.toPath());
+			return new String(bytes);
+		}
+		catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private static void writeString(File file, String text) {
+		try {
+			Files.write(file.toPath(), text.getBytes());
+		}
+		catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/GitHubApi.java

@@ -0,0 +1,179 @@
+package org.springframework.security.convention.versions;
+
+import com.apollographql.apollo.ApolloCall;
+import com.apollographql.apollo.ApolloClient;
+import com.apollographql.apollo.api.Input;
+import com.apollographql.apollo.api.Response;
+import com.apollographql.apollo.exception.ApolloException;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import org.jetbrains.annotations.NotNull;
+import reactor.core.publisher.Mono;
+import reactor.util.retry.Retry;
+import reactor.util.retry.RetrySpec;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class GitHubApi {
+
+	private final ApolloClient apolloClient;
+
+	public GitHubApi(String githubToken) {
+		if (githubToken == null) {
+			throw new IllegalArgumentException("githubToken is required. You can set it using -PgitHubAccessToken=");
+		}
+		OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
+		clientBuilder.addInterceptor(new AuthorizationInterceptor(githubToken));
+		this.apolloClient = ApolloClient.builder()
+				.serverUrl("https://api.github.com/graphql")
+				.okHttpClient(clientBuilder.build())
+				.build();
+	}
+
+	public Mono<FindCreateIssueResult> findCreateIssueInput(String owner, String name, String milestone) {
+		String label = "\"type: dependency-upgrade\"";
+		FindCreateIssueInputQuery findCreateIssueInputQuery = new FindCreateIssueInputQuery(owner, name, Input.optional(label), Input.optional(milestone));
+		return Mono.create( sink -> this.apolloClient.query(findCreateIssueInputQuery)
+				.enqueue(new ApolloCall.Callback<FindCreateIssueInputQuery.Data>() {
+					@Override
+					public void onResponse(@NotNull Response<FindCreateIssueInputQuery.Data> response) {
+						if (response.hasErrors()) {
+							sink.error(new RuntimeException(response.getErrors().stream().map(e -> e.getMessage()).collect(Collectors.joining(" "))));
+						} else {
+							FindCreateIssueInputQuery.Data data = response.getData();
+							FindCreateIssueInputQuery.Repository repository = data.repository();
+							List<String> labels = repository.labels().nodes().stream().map(FindCreateIssueInputQuery.Node::id).collect(Collectors.toList());
+							if (labels.isEmpty()) {
+								sink.error(new IllegalArgumentException("Could not find label for " + label));
+								return;
+							}
+							Optional<String> firstMilestoneId = repository.milestones().nodes().stream().map(FindCreateIssueInputQuery.Node1::id).findFirst();
+							if (!firstMilestoneId.isPresent()) {
+								sink.error(new IllegalArgumentException("Could not find OPEN milestone id for " + milestone));
+								return;
+							}
+							String milestoneId = firstMilestoneId.get();
+							String repositoryId = repository.id();
+							String assigneeId = data.viewer().id();
+							sink.success(new FindCreateIssueResult(repositoryId, labels, milestoneId, assigneeId));
+						}
+					}
+					@Override
+					public void onFailure(@NotNull ApolloException e) {
+						sink.error(e);
+					}
+				}));
+	}
+
+	public static class FindCreateIssueResult {
+		private final String repositoryId;
+		private final List<String> labelIds;
+		private final String milestoneId;
+		private final String assigneeId;
+
+		public FindCreateIssueResult(String repositoryId, List<String> labelIds, String milestoneId, String assigneeId) {
+			this.repositoryId = repositoryId;
+			this.labelIds = labelIds;
+			this.milestoneId = milestoneId;
+			this.assigneeId = assigneeId;
+		}
+
+		public String getRepositoryId() {
+			return repositoryId;
+		}
+
+		public List<String> getLabelIds() {
+			return labelIds;
+		}
+
+		public String getMilestoneId() {
+			return milestoneId;
+		}
+
+		public String getAssigneeId() {
+			return assigneeId;
+		}
+	}
+
+	public Mono<RateLimitQuery.RateLimit> findRateLimit() {
+		return Mono.create( sink -> this.apolloClient.query(new RateLimitQuery())
+			.enqueue(new ApolloCall.Callback<RateLimitQuery.Data>() {
+				@Override
+				public void onResponse(@NotNull Response<RateLimitQuery.Data> response) {
+					if (response.hasErrors()) {
+						sink.error(new RuntimeException(response.getErrors().stream().map(e -> e.getMessage()).collect(Collectors.joining(" "))));
+					} else {
+						sink.success(response.getData().rateLimit());
+					}
+				}
+				@Override
+				public void onFailure(@NotNull ApolloException e) {
+					sink.error(e);
+				}
+			}));
+	}
+
+	public Mono<Integer> createIssue(String repositoryId, String title, List<String> labelIds, String milestoneId, String assigneeId) {
+		CreateIssueInputMutation createIssue = new CreateIssueInputMutation.Builder()
+				.repositoryId(repositoryId)
+				.title(title)
+				.labelIds(labelIds)
+				.milestoneId(milestoneId)
+				.assigneeId(assigneeId)
+				.build();
+		return Mono.create( sink -> this.apolloClient.mutate(createIssue)
+				.enqueue(new ApolloCall.Callback<CreateIssueInputMutation.Data>() {
+					@Override
+					public void onResponse(@NotNull Response<CreateIssueInputMutation.Data> response) {
+						if (response.hasErrors()) {
+							String message = response.getErrors().stream().map(e -> e.getMessage() + " " + e.getCustomAttributes() + " " + e.getLocations()).collect(Collectors.joining(" "));
+							if (message.contains("was submitted too quickly")) {
+								sink.error(new SubmittedTooQuick(message));
+							} else {
+								sink.error(new RuntimeException(message));
+							}
+						} else {
+							sink.success(response.getData().createIssue().issue().number());
+						}
+					}
+					@Override
+					public void onFailure(@NotNull ApolloException e) {
+						sink.error(e);
+					}
+				}))
+				.retryWhen(
+					RetrySpec.fixedDelay(3, Duration.ofMinutes(1))
+						.filter(SubmittedTooQuick.class::isInstance)
+						.doBeforeRetry(r -> System.out.println("Pausing for 1 minute and then retrying due to receiving \"submitted too quickly\" error from GitHub API"))
+				)
+				.cast(Integer.class);
+	}
+
+	public static class SubmittedTooQuick extends RuntimeException {
+		public SubmittedTooQuick(String message) {
+			super(message);
+		}
+	}
+
+	private static class AuthorizationInterceptor implements Interceptor {
+
+		private final String token;
+
+		public AuthorizationInterceptor(String token) {
+			this.token = token;
+		}
+
+		@Override
+		public okhttp3.Response intercept(Chain chain) throws IOException {
+			Request request = chain.request().newBuilder()
+					.addHeader("Authorization", "Bearer " + this.token).build();
+			return chain.proceed(request);
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/TransitiveDependencyLookupUtils.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.convention.versions;
+
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+import java.io.IOException;
+import java.io.InputStream;
+
+class TransitiveDependencyLookupUtils {
+	static String OIDC_SDK_NAME = "oauth2-oidc-sdk";
+	static String NIMBUS_JOSE_JWT_NAME = "nimbus-jose-jwt";
+
+	private static OkHttpClient client = new OkHttpClient();
+
+	static String lookupJwtVersion(String oauthSdcVersion) {
+		Request request = new Request.Builder()
+				.get()
+				.url("https://repo.maven.apache.org/maven2/com/nimbusds/" + OIDC_SDK_NAME + "/" + oauthSdcVersion + "/" + OIDC_SDK_NAME + "-" + oauthSdcVersion + ".pom")
+				.build();
+		try (Response response = client.newCall(request).execute()) {
+			if (!response.isSuccessful()) {
+				throw new IOException("Unexpected code " + response);
+			}
+			InputStream inputStream = response.body().byteStream();
+			return getVersion(inputStream);
+
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private static String getVersion(InputStream inputStream) throws ParserConfigurationException, IOException, SAXException, XPathExpressionException {
+		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+		dbf.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+		DocumentBuilder db = dbf.newDocumentBuilder();
+
+		Document doc = db.parse(inputStream);
+
+		doc.getDocumentElement().normalize();
+
+		XPath xPath = XPathFactory.newInstance().newXPath();
+		return xPath.evaluate("/project/dependencies/dependency/version[../artifactId/text() = \"" + NIMBUS_JOSE_JWT_NAME + "\"]", doc);
+	}
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/UpdateDependenciesExtension.java

@@ -0,0 +1,198 @@
+package org.springframework.security.convention.versions;
+
+import com.github.benmanes.gradle.versions.updates.resolutionstrategy.ComponentSelectionRulesWithCurrent;
+import com.github.benmanes.gradle.versions.updates.resolutionstrategy.ComponentSelectionWithCurrent;
+import com.github.benmanes.gradle.versions.updates.resolutionstrategy.ResolutionStrategyWithCurrent;
+import org.gradle.api.Action;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+
+public class UpdateDependenciesExtension {
+	private Supplier<List<File>> files;
+
+	private UpdateMode updateMode = UpdateMode.COMMIT;
+
+	private DependencyExcludes dependencyExcludes = new DependencyExcludes();
+
+	private GitHub gitHub = new GitHub();
+
+	public UpdateDependenciesExtension(Supplier<List<File>> files) {
+		this.files = files;
+	}
+
+	public void setUpdateMode(UpdateMode updateMode) {
+		this.updateMode = updateMode;
+	}
+
+	public UpdateMode getUpdateMode() {
+		return updateMode;
+	}
+
+	GitHub getGitHub() {
+		return this.gitHub;
+	}
+
+	DependencyExcludes getExcludes() {
+		return dependencyExcludes;
+	}
+
+	Supplier<List<File>> getFiles() {
+		return files;
+	}
+
+	public void setFiles(Supplier<List<File>> files) {
+		this.files = files;
+	}
+
+	public void addFiles(Supplier<List<File>> files) {
+		Supplier<List<File>> original = this.files;
+		setFiles(() -> {
+			List<File> result = new ArrayList<>(original.get());
+			result.addAll(files.get());
+			return result;
+		});
+	}
+
+	public void dependencyExcludes(Action<DependencyExcludes> excludes) {
+		excludes.execute(this.dependencyExcludes);
+	}
+
+	public void gitHub(Action<GitHub> gitHub) {
+		gitHub.execute(this.gitHub);
+	}
+
+	public enum UpdateMode {
+		COMMIT,
+		GITHUB_ISSUE
+	}
+
+	public class GitHub {
+		private String organization;
+
+		private String repository;
+
+		private String accessToken;
+
+		private String milestone;
+
+		public String getOrganization() {
+			return organization;
+		}
+
+		public void setOrganization(String organization) {
+			this.organization = organization;
+		}
+
+		public String getRepository() {
+			return repository;
+		}
+
+		public void setRepository(String repository) {
+			this.repository = repository;
+		}
+
+		public String getAccessToken() {
+			return accessToken;
+		}
+
+		public void setAccessToken(String accessToken) {
+			this.accessToken = accessToken;
+		}
+
+		public String getMilestone() {
+			return milestone;
+		}
+
+		public void setMilestone(String milestone) {
+			this.milestone = milestone;
+		}
+	}
+
+	/**
+	 * Consider creating some Predicates instead since they are composible
+	 */
+	public class DependencyExcludes {
+		private List<Action<ComponentSelectionWithCurrent>> actions = new ArrayList<>();
+		private List<Action<ComponentSelectionRulesWithCurrent>> components = new ArrayList<>();
+
+		List<Action<ComponentSelectionWithCurrent>> getActions() {
+			return actions;
+		}
+
+		public List<Action<ComponentSelectionRulesWithCurrent>> getComponents() {
+			return components;
+		}
+
+		public DependencyExcludes alphaBetaVersions() {
+			this.actions.add(excludeVersionWithRegex("(?i).*?(alpha|beta).*", "an alpha or beta version"));
+			return this;
+		}
+
+		public DependencyExcludes majorVersionBump() {
+			this.actions.add((selection) -> {
+				String currentVersion = selection.getCurrentVersion();
+				int separator = currentVersion.indexOf(".");
+				String major = separator > 0 ? currentVersion.substring(0, separator) : currentVersion;
+				String candidateVersion = selection.getCandidate().getVersion();
+				Pattern calVerPattern = Pattern.compile("\\d\\d\\d\\d.*");
+				boolean isCalVer = calVerPattern.matcher(candidateVersion).matches();
+				if (!isCalVer && !candidateVersion.startsWith(major)) {
+					selection.reject("Cannot upgrade to new Major Version");
+				}
+			});
+			return this;
+		}
+
+		public DependencyExcludes minorVersionBump() {
+			this.actions.add(createExcludeMinorVersionBump());
+			return this;
+		}
+
+		public Action<ComponentSelectionWithCurrent> createExcludeMinorVersionBump() {
+			return (selection) -> {
+				String currentVersion = selection.getCurrentVersion();
+				int majorSeparator = currentVersion.indexOf(".");
+				int separator = currentVersion.indexOf(".", majorSeparator + 1);
+				String majorMinor = separator > 0 ? currentVersion.substring(0, separator) : currentVersion;
+				String candidateVersion = selection.getCandidate().getVersion();
+				if (!candidateVersion.startsWith(majorMinor)) {
+					selection.reject("Cannot upgrade to new Minor Version");
+				}
+			};
+		}
+
+		public DependencyExcludes releaseCandidatesVersions() {
+			this.actions.add(excludeVersionWithRegex("(?i).*?rc.*", "a release candidate version"));
+			return this;
+		}
+
+		public DependencyExcludes milestoneVersions() {
+			this.actions.add(excludeVersionWithRegex("(?i).*?m\\d+.*", "a milestone version"));
+			return this;
+		}
+
+		public DependencyExcludes snapshotVersions() {
+			this.actions.add(excludeVersionWithRegex(".*?-SNAPSHOT.*", "a SNAPSHOT version"));
+			return this;
+		}
+
+		public DependencyExcludes addRule(Action<ComponentSelectionRulesWithCurrent> rule) {
+			this.components.add(rule);
+			return this;
+		}
+
+		private Action<ComponentSelectionWithCurrent> excludeVersionWithRegex(String regex, String reason) {
+			Pattern pattern = Pattern.compile(regex);
+			return (selection) -> {
+				String candidateVersion = selection.getCandidate().getVersion();
+				if (pattern.matcher(candidateVersion).matches()) {
+					selection.reject(candidateVersion + " is not allowed because it is " + reason);
+				}
+			};
+		}
+	}
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/UpdateDependenciesPlugin.java

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2019-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.convention.versions;
+
+import com.github.benmanes.gradle.versions.reporter.result.Dependency;
+import com.github.benmanes.gradle.versions.reporter.result.DependencyOutdated;
+import com.github.benmanes.gradle.versions.reporter.result.Result;
+import com.github.benmanes.gradle.versions.reporter.result.VersionAvailable;
+import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask;
+import com.github.benmanes.gradle.versions.updates.gradle.GradleUpdateResult;
+import com.github.benmanes.gradle.versions.updates.resolutionstrategy.ComponentSelectionRulesWithCurrent;
+import com.github.benmanes.gradle.versions.updates.resolutionstrategy.ComponentSelectionWithCurrent;
+import com.github.benmanes.gradle.versions.updates.resolutionstrategy.ResolutionStrategyWithCurrent;
+import groovy.lang.Closure;
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
+import reactor.core.publisher.Mono;
+
+import java.io.File;
+import java.time.Duration;
+import java.util.*;
+import java.util.function.Supplier;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.springframework.security.convention.versions.TransitiveDependencyLookupUtils.NIMBUS_JOSE_JWT_NAME;
+import static org.springframework.security.convention.versions.TransitiveDependencyLookupUtils.OIDC_SDK_NAME;
+
+public class UpdateDependenciesPlugin implements Plugin<Project> {
+	private GitHubApi gitHubApi;
+
+	@Override
+	public void apply(Project project) {
+		UpdateDependenciesExtension updateDependenciesSettings = project.getExtensions().create("updateDependenciesSettings", UpdateDependenciesExtension.class, defaultFiles(project));
+		if (project.hasProperty("updateMode")) {
+			String updateMode = String.valueOf(project.findProperty("updateMode"));
+			updateDependenciesSettings.setUpdateMode(UpdateDependenciesExtension.UpdateMode.valueOf(updateMode));
+		}
+		if (project.hasProperty("nextVersion")) {
+			String nextVersion = String.valueOf(project.findProperty("nextVersion"));
+			updateDependenciesSettings.getGitHub().setMilestone(nextVersion);
+		}
+		if (project.hasProperty("gitHubAccessToken")) {
+			String gitHubAccessToken = String.valueOf(project.findProperty("gitHubAccessToken"));
+			updateDependenciesSettings.getGitHub().setAccessToken(gitHubAccessToken);
+		}
+		project.getTasks().register("updateDependencies", DependencyUpdatesTask.class, new Action<DependencyUpdatesTask>() {
+			@Override
+			public void execute(DependencyUpdatesTask updateDependencies) {
+				updateDependencies.setDescription("Update the dependencies");
+				updateDependencies.setCheckConstraints(true);
+				updateDependencies.setOutputFormatter(new Closure<Void>(null) {
+					@Override
+					public Void call(Object argument) {
+						Result result = (Result) argument;
+						if (gitHubApi == null && updateDependenciesSettings.getUpdateMode() != UpdateDependenciesExtension.UpdateMode.COMMIT) {
+							gitHubApi = new GitHubApi(updateDependenciesSettings.getGitHub().getAccessToken());
+						}
+						updateDependencies(result, project, updateDependenciesSettings);
+						updateGradleVersion(result, project, updateDependenciesSettings);
+						return null;
+					}
+				});
+				updateDependencies.resolutionStrategy(new Action<ResolutionStrategyWithCurrent>() {
+					@Override
+					public void execute(ResolutionStrategyWithCurrent resolution) {
+						resolution.componentSelection(new Action<ComponentSelectionRulesWithCurrent>() {
+							@Override
+							public void execute(ComponentSelectionRulesWithCurrent components) {
+								updateDependenciesSettings.getExcludes().getActions().forEach((action) -> {
+									components.all(action);
+								});
+								updateDependenciesSettings.getExcludes().getComponents().forEach((action) -> {
+									action.execute(components);
+								});
+								components.all((selection) -> {
+									ModuleComponentIdentifier candidate = selection.getCandidate();
+									if (candidate.getGroup().startsWith("org.apache.directory.") && !candidate.getVersion().equals(selection.getCurrentVersion())) {
+										selection.reject("org.apache.directory.* has breaking changes in newer versions");
+									}
+								});
+								String jaxbBetaRegex = ".*?b\\d+.*";
+								components.withModule("javax.xml.bind:jaxb-api", excludeWithRegex(jaxbBetaRegex, "Reject jaxb-api beta versions"));
+								components.withModule("com.sun.xml.bind:jaxb-impl", excludeWithRegex(jaxbBetaRegex, "Reject jaxb-api beta versions"));
+								components.withModule("commons-collections:commons-collections", excludeWithRegex("^\\d{3,}.*", "Reject commons-collections date based releases"));
+							}
+						});
+					}
+				});
+			}
+		});
+	}
+
+	private void updateDependencies(Result result, Project project, UpdateDependenciesExtension updateDependenciesSettings) {
+		SortedSet<DependencyOutdated> dependencies = result.getOutdated().getDependencies();
+		if (dependencies.isEmpty()) {
+			return;
+		}
+		Map<String, List<DependencyOutdated>> groups = new LinkedHashMap<>();
+		dependencies.forEach(outdated -> {
+			groups.computeIfAbsent(outdated.getGroup(), (key) -> new ArrayList<>()).add(outdated);
+		});
+		List<DependencyOutdated> nimbusds = groups.getOrDefault("com.nimbusds", new ArrayList<>());
+		DependencyOutdated oidcSdc = nimbusds.stream().filter(d -> d.getName().equals(OIDC_SDK_NAME)).findFirst().orElseGet(() -> null);
+		if(oidcSdc != null) {
+			String oidcVersion = updatedVersion(oidcSdc);
+			String jwtVersion = TransitiveDependencyLookupUtils.lookupJwtVersion(oidcVersion);
+
+			Dependency nimbusJoseJwtDependency = result.getCurrent().getDependencies().stream().filter(d -> d.getName().equals(NIMBUS_JOSE_JWT_NAME)).findFirst().get();
+			DependencyOutdated outdatedJwt = new DependencyOutdated();
+			outdatedJwt.setVersion(nimbusJoseJwtDependency.getVersion());
+			outdatedJwt.setGroup(oidcSdc.getGroup());
+			outdatedJwt.setName(NIMBUS_JOSE_JWT_NAME);
+			VersionAvailable available = new VersionAvailable();
+			available.setRelease(jwtVersion);
+			outdatedJwt.setAvailable(available);
+			nimbusds.add(outdatedJwt);
+		}
+		File gradlePropertiesFile = project.getRootProject().file(Project.GRADLE_PROPERTIES);
+		Mono<GitHubApi.FindCreateIssueResult> createIssueResult = createIssueResultMono(updateDependenciesSettings);
+		List<File> filesWithDependencies = updateDependenciesSettings.getFiles().get();
+		groups.forEach((group, outdated) -> {
+			outdated.forEach((dependency) -> {
+				String ga = dependency.getGroup() + ":" + dependency.getName() + ":";
+				String originalDependency = ga + dependency.getVersion();
+				String replacementDependency = ga + updatedVersion(dependency);
+				System.out.println("Update " + originalDependency + " to " + replacementDependency);
+				filesWithDependencies.forEach((fileWithDependency) -> {
+					updateDependencyInlineVersion(fileWithDependency, dependency);
+					updateDependencyWithVersionVariable(fileWithDependency, gradlePropertiesFile, dependency);
+				});
+			});
+
+			// commit
+			DependencyOutdated firstDependency = outdated.get(0);
+			String updatedVersion = updatedVersion(firstDependency);
+			String title = outdated.size() == 1 ? "Update " + firstDependency.getName() + " to " + updatedVersion : "Update " + firstDependency.getGroup() + " to " + updatedVersion;
+			afterGroup(updateDependenciesSettings, project.getRootDir(), title, createIssueResult);
+		});
+	}
+
+	private void afterGroup(UpdateDependenciesExtension updateDependenciesExtension, File rootDir, String title, Mono<GitHubApi.FindCreateIssueResult> createIssueResultMono) {
+
+		String commitMessage = title;
+		if (updateDependenciesExtension.getUpdateMode() == UpdateDependenciesExtension.UpdateMode.GITHUB_ISSUE) {
+			GitHubApi.FindCreateIssueResult createIssueResult = createIssueResultMono.block();
+			Integer issueNumber = gitHubApi.createIssue(createIssueResult.getRepositoryId(), title, createIssueResult.getLabelIds(), createIssueResult.getMilestoneId(), createIssueResult.getAssigneeId()).delayElement(Duration.ofSeconds(1)).block();
+			commitMessage += "\n\nCloses gh-" + issueNumber;
+		}
+		CommandLineUtils.runCommand(rootDir, "git", "commit", "-am", commitMessage);
+	}
+
+	private Mono<GitHubApi.FindCreateIssueResult> createIssueResultMono(UpdateDependenciesExtension updateDependenciesExtension) {
+		return Mono.defer(() -> {
+			UpdateDependenciesExtension.GitHub gitHub = updateDependenciesExtension.getGitHub();
+			return gitHubApi.findCreateIssueInput(gitHub.getOrganization(), gitHub.getRepository(), gitHub.getMilestone()).cache();
+		});
+	}
+
+	private void updateGradleVersion(Result result, Project project, UpdateDependenciesExtension updateDependenciesSettings) {
+		if (!result.getGradle().isEnabled()) {
+			return;
+		}
+		GradleUpdateResult current = result.getGradle().getCurrent();
+		GradleUpdateResult running = result.getGradle().getRunning();
+		if (current.compareTo(running) > 0) {
+			String title = "Update Gradle to " + current.getVersion();
+			System.out.println(title);
+			CommandLineUtils.runCommand(project.getRootDir(), "./gradlew", "wrapper", "--gradle-version", current.getVersion(), "--no-daemon");
+			afterGroup(updateDependenciesSettings, project.getRootDir(), title, createIssueResultMono(updateDependenciesSettings));
+		}
+	}
+
+	private static Supplier<List<File>> defaultFiles(Project project) {
+		return () -> {
+			List<File> result = new ArrayList<>();
+			result.add(project.getBuildFile());
+			project.getChildProjects().values().forEach((childProject) ->
+					result.add(childProject.getBuildFile())
+			);
+			result.add(project.getRootProject().file("buildSrc/build.gradle"));
+			return result;
+		};
+	}
+
+	static Action<ComponentSelectionWithCurrent> excludeWithRegex(String regex, String reason) {
+		Pattern pattern = Pattern.compile(regex);
+		return (selection) -> {
+			String candidateVersion = selection.getCandidate().getVersion();
+			if (pattern.matcher(candidateVersion).matches()) {
+				selection.reject(candidateVersion + " is not allowed because it is " + reason);
+			}
+		};
+	}
+
+	static void updateDependencyInlineVersion(File buildFile, DependencyOutdated dependency){
+		String ga = dependency.getGroup() + ":" + dependency.getName() + ":";
+		String originalDependency = ga + dependency.getVersion();
+		String replacementDependency = ga + updatedVersion(dependency);
+		FileUtils.replaceFileText(buildFile, buildFileText -> buildFileText.replace(originalDependency, replacementDependency));
+	}
+
+	static void updateDependencyWithVersionVariable(File scanFile, File gradlePropertiesFile, DependencyOutdated dependency) {
+		if (!gradlePropertiesFile.exists()) {
+			return;
+		}
+		FileUtils.replaceFileText(gradlePropertiesFile, (gradlePropertiesText) -> {
+			String ga = dependency.getGroup() + ":" + dependency.getName() + ":";
+			Pattern pattern = Pattern.compile("\"" + ga + "\\$\\{?([^'\"]+?)\\}?\"");
+			String buildFileText = FileUtils.readString(scanFile);
+			Matcher matcher = pattern.matcher(buildFileText);
+			while (matcher.find()) {
+				String versionVariable = matcher.group(1);
+				gradlePropertiesText = gradlePropertiesText.replace(versionVariable + "=" + dependency.getVersion(), versionVariable + "=" + updatedVersion(dependency));
+			}
+			return gradlePropertiesText;
+		});
+	}
+
+	private static String updatedVersion(DependencyOutdated dependency) {
+		VersionAvailable available = dependency.getAvailable();
+		String release = available.getRelease();
+		if (release != null) {
+			return release;
+		}
+		return available.getMilestone();
+	}
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/UpdateProjectVersionPlugin.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.convention.versions;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+public class UpdateProjectVersionPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getTasks().register("updateProjectVersion", UpdateProjectVersionTask.class, new Action<UpdateProjectVersionTask>() {
+			@Override
+			public void execute(UpdateProjectVersionTask updateProjectVersionTask) {
+				updateProjectVersionTask.setGroup("Release");
+				updateProjectVersionTask.setDescription("Updates the project version to the next release in gradle.properties");
+				updateProjectVersionTask.dependsOn("gitHubNextReleaseMilestone");
+				updateProjectVersionTask.getNextVersionFile().fileProvider(project.provider(() -> project.file("next-release.yml")));
+			}
+		});
+		project.getTasks().register("updateToSnapshotVersion", UpdateToSnapshotVersionTask.class, new Action<UpdateToSnapshotVersionTask>() {
+			@Override
+			public void execute(UpdateToSnapshotVersionTask updateToSnapshotVersionTask) {
+				updateToSnapshotVersionTask.setGroup("Release");
+				updateToSnapshotVersionTask.setDescription(
+						"Updates the project version to the next snapshot in gradle.properties");
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/UpdateProjectVersionTask.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.convention.versions;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.Project;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.TaskAction;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+import org.springframework.gradle.github.milestones.NextVersionYml;
+
+public abstract class UpdateProjectVersionTask extends DefaultTask {
+
+	@InputFile
+	public abstract RegularFileProperty getNextVersionFile();
+
+	@TaskAction
+	public void checkReleaseDueToday() throws FileNotFoundException {
+		File nextVersionFile = getNextVersionFile().getAsFile().get();
+		Yaml yaml = new Yaml(new Constructor(NextVersionYml.class));
+		NextVersionYml nextVersionYml = yaml.load(new FileInputStream(nextVersionFile));
+		String nextVersion = nextVersionYml.getVersion();
+		if (nextVersion == null) {
+			throw new IllegalArgumentException(
+					"Could not find version property in provided file " + nextVersionFile.getName());
+		}
+		String currentVersion = getProject().getVersion().toString();
+		File gradlePropertiesFile = getProject().getRootProject().file(Project.GRADLE_PROPERTIES);
+		if (!gradlePropertiesFile.exists()) {
+			return;
+		}
+		System.out.println("Updating the project version in " + Project.GRADLE_PROPERTIES + " from " + currentVersion
+				+ " to " + nextVersion);
+		FileUtils.replaceFileText(gradlePropertiesFile, (gradlePropertiesText) -> {
+			gradlePropertiesText = gradlePropertiesText.replace("version=" + currentVersion, "version=" + nextVersion);
+			return gradlePropertiesText;
+		});
+	}
+
+}

buildSrc/src/main/java/org/springframework/security/convention/versions/UpdateToSnapshotVersionTask.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2019-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.convention.versions;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.File;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public abstract class UpdateToSnapshotVersionTask extends DefaultTask {
+
+	private static final String RELEASE_VERSION_PATTERN = "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(-M\\d+|-RC\\d+)?$";
+
+	@TaskAction
+	public void updateToSnapshotVersion() {
+		String currentVersion = getProject().getVersion().toString();
+		File gradlePropertiesFile = getProject().getRootProject().file(Project.GRADLE_PROPERTIES);
+		if (!gradlePropertiesFile.exists()) {
+			return;
+		}
+		String nextVersion = calculateNextSnapshotVersion(currentVersion);
+		System.out.println("Updating the project version in " + Project.GRADLE_PROPERTIES + " from " + currentVersion
+				+ " to " + nextVersion);
+		FileUtils.replaceFileText(gradlePropertiesFile, (gradlePropertiesText) -> {
+			gradlePropertiesText = gradlePropertiesText.replace("version=" + currentVersion, "version=" + nextVersion);
+			return gradlePropertiesText;
+		});
+	}
+
+	private String calculateNextSnapshotVersion(String currentVersion) {
+		Pattern releaseVersionPattern = Pattern.compile(RELEASE_VERSION_PATTERN);
+		Matcher releaseVersion = releaseVersionPattern.matcher(currentVersion);
+
+		if (releaseVersion.find()) {
+			String majorSegment = releaseVersion.group(1);
+			String minorSegment = releaseVersion.group(2);
+			String patchSegment = releaseVersion.group(3);
+			String modifier = releaseVersion.group(4);
+			if (modifier == null) {
+				patchSegment = String.valueOf(Integer.parseInt(patchSegment) + 1);
+			}
+			System.out.println("modifier = " + modifier);
+			return String.format("%s.%s.%s-SNAPSHOT", majorSegment, minorSegment, patchSegment);
+		}
+		else {
+			throw new IllegalStateException(
+					"Cannot calculate next snapshot version because the current project version does not conform to the expected format");
+		}
+	}
+
+}

buildSrc/src/main/java/s101/S101Configure.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package s101;
+
+import java.io.File;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.TaskAction;
+
+public class S101Configure extends DefaultTask {
+	@TaskAction
+	public void configure() throws Exception {
+		S101PluginExtension extension = getProject().getExtensions().getByType(S101PluginExtension.class);
+		File buildDirectory = extension.getInstallationDirectory().get();
+		File projectDirectory = extension.getConfigurationDirectory().get();
+		S101Configurer configurer = new S101Configurer(getProject());
+		configurer.configure(buildDirectory, projectDirectory);
+	}
+
+
+}

buildSrc/src/main/java/s101/S101Configurer.java

@@ -0,0 +1,311 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package s101;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.UncheckedIOException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import com.gargoylesoftware.htmlunit.WebClient;
+import com.gargoylesoftware.htmlunit.html.HtmlAnchor;
+import com.gargoylesoftware.htmlunit.html.HtmlPage;
+import com.github.mustachejava.DefaultMustacheFactory;
+import com.github.mustachejava.Mustache;
+import com.github.mustachejava.MustacheFactory;
+import org.apache.commons.io.IOUtils;
+import org.gradle.api.Project;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.SourceSetContainer;
+
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+
+public class S101Configurer {
+	private static final Pattern VERSION = Pattern.compile("<local-project .* version=\"(.*?)\"");
+
+	private static final int BUFFER = 1024;
+	private static final long TOOBIG = 0x10000000; // ~268M
+	private static final int TOOMANY = 200;
+
+	private final MustacheFactory mustache = new DefaultMustacheFactory();
+	private final Mustache hspTemplate;
+	private final Mustache repositoryTemplate;
+
+	private final Path licenseDirectory;
+
+	private final Project project;
+	private final Logger logger;
+
+	public S101Configurer(Project project) {
+		this.project = project;
+		this.logger = project.getLogger();
+		Resource template = new ClassPathResource("s101/project.java.hsp");
+		try (InputStream is = template.getInputStream()) {
+			this.hspTemplate = this.mustache.compile(new InputStreamReader(is), "project");
+		} catch (IOException ex) {
+			throw new UncheckedIOException(ex);
+		}
+		template = new ClassPathResource("s101/repository.xml");
+		try (InputStream is = template.getInputStream()) {
+			this.repositoryTemplate = this.mustache.compile(new InputStreamReader(is), "repository");
+		} catch (IOException ex) {
+			throw new UncheckedIOException(ex);
+		}
+		this.licenseDirectory = new File(System.getProperty("user.home") + "/.Structure101/java").toPath();
+	}
+
+	public void license(String licenseId) {
+		Path licenseFile = this.licenseDirectory.resolve(".structure101license.properties");
+		if (needsLicense(licenseFile, licenseId)) {
+			writeLicense(licenseFile, licenseId);
+		}
+	}
+
+	private boolean needsLicense(Path licenseFile, String licenseId) {
+		if (!licenseFile.toFile().exists()) {
+			return true;
+		}
+		try {
+			String license = new String(Files.readAllBytes(licenseFile));
+			return !license.contains(licenseId);
+		} catch (IOException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private void writeLicense(Path licenseFile, String licenseId) {
+		if (!this.licenseDirectory.toFile().mkdirs()) {
+			this.licenseDirectory.forEach((path) -> path.toFile().delete());
+		}
+		try (PrintWriter pw = new PrintWriter(licenseFile.toFile())) {
+			pw.println("licensecode=" + licenseId);
+		} catch (IOException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	public void install(File installationDirectory, File configurationDirectory) {
+		deleteDirectory(installationDirectory);
+		installBuildTool(installationDirectory, configurationDirectory);
+	}
+
+	public void configure(File installationDirectory, File configurationDirectory) {
+		deleteDirectory(configurationDirectory);
+		String version = computeVersionFromInstallation(installationDirectory);
+		configureProject(version, configurationDirectory);
+	}
+
+	private String computeVersionFromInstallation(File installationDirectory) {
+		File buildJar = new File(installationDirectory, "structure101-java-build.jar");
+		try (JarInputStream input = new JarInputStream(new FileInputStream(buildJar))) {
+			JarEntry entry;
+			while ((entry = input.getNextJarEntry()) != null) {
+				if (entry.getName().contains("structure101-build.properties")) {
+					Properties properties = new Properties();
+					properties.load(input);
+					return properties.getProperty("s101-build");
+				}
+			}
+		} catch (Exception ex) {
+			throw new RuntimeException(ex);
+		}
+		throw new IllegalStateException("Unable to determine Structure101 version");
+	}
+
+	private boolean deleteDirectory(File directoryToBeDeleted) {
+		File[] allContents = directoryToBeDeleted.listFiles();
+		if (allContents != null) {
+			for (File file : allContents) {
+				deleteDirectory(file);
+			}
+		}
+		return directoryToBeDeleted.delete();
+	}
+
+	private String installBuildTool(File installationDirectory, File configurationDirectory) {
+		String source = "https://structure101.com/binaries/v6";
+		try (final WebClient webClient = new WebClient()) {
+			HtmlPage page = webClient.getPage(source);
+			Matcher matcher = null;
+			for (HtmlAnchor anchor : page.getAnchors()) {
+				Matcher candidate = Pattern.compile("(structure101-build-java-all-)(.*).zip").matcher(anchor.getHrefAttribute());
+				if (candidate.find()) {
+					matcher = candidate;
+				}
+			}
+			if (matcher == null) {
+				return null;
+			}
+			copyZipToFilesystem(source, installationDirectory, matcher.group(1) + matcher.group(2));
+			return matcher.group(2);
+		} catch (Exception ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private void copyZipToFilesystem(String source, File destination, String name) {
+		try (ZipInputStream in = new ZipInputStream(new URL(source + "/" + name + ".zip").openStream())) {
+			ZipEntry entry;
+			String build = destination.getName();
+			int entries = 0;
+			long size = 0;
+			while ((entry = in.getNextEntry()) != null) {
+				if (entry.getName().equals(name + "/")) {
+					destination.mkdirs();
+				} else if (entry.getName().startsWith(name)) {
+					if (entries++ > TOOMANY) {
+						throw new IllegalArgumentException("Zip file has more entries than expected");
+					}
+					if (size + BUFFER > TOOBIG) {
+						throw new IllegalArgumentException("Zip file is larger than expected");
+					}
+					String filename = entry.getName().replace(name, build);
+					if (filename.contains("maven")) {
+						continue;
+					}
+					if (filename.contains("jxbrowser")) {
+						continue;
+					}
+					if (filename.contains("jetty")) {
+						continue;
+					}
+					if (filename.contains("jfreechart")) {
+						continue;
+					}
+					if (filename.contains("piccolo2d")) {
+						continue;
+					}
+					if (filename.contains("plexus")) {
+						continue;
+					}
+					if (filename.contains("websocket")) {
+						continue;
+					}
+					validateFilename(filename, build);
+					this.logger.info("Downloading " + filename);
+					try (OutputStream out = new FileOutputStream(new File(destination.getParentFile(), filename))) {
+						byte[] data = new byte[BUFFER];
+						int read;
+						while ((read = in.read(data, 0, BUFFER)) != -1 && TOOBIG - size >= read) {
+							out.write(data, 0, read);
+							size += read;
+						}
+					}
+				}
+			}
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private String validateFilename(String filename, String intendedDir)
+			throws java.io.IOException {
+		File f = new File(filename);
+		String canonicalPath = f.getCanonicalPath();
+
+		File iD = new File(intendedDir);
+		String canonicalID = iD.getCanonicalPath();
+
+		if (canonicalPath.startsWith(canonicalID)) {
+			return canonicalPath;
+		} else {
+			throw new IllegalArgumentException("File is outside extraction target directory.");
+		}
+	}
+
+	private void configureProject(String version, File configurationDirectory) {
+		configurationDirectory.mkdirs();
+		Map<String, Object> model = hspTemplateValues(version, configurationDirectory);
+		copyToProject(this.hspTemplate, model, new File(configurationDirectory, "project.java.hsp"));
+		copyToProject("s101/config.xml", new File(configurationDirectory, "config.xml"));
+		File repository = new File(configurationDirectory, "repository");
+		File snapshots = new File(repository, "snapshots");
+		if (!snapshots.exists() && !snapshots.mkdirs()) {
+			throw new IllegalStateException("Unable to create snapshots directory");
+		}
+		copyToProject(this.repositoryTemplate, model, new File(repository, "repository.xml"));
+	}
+
+	private void copyToProject(String location, File destination) {
+		Resource resource = new ClassPathResource(location);
+		try (InputStream is = resource.getInputStream();
+			OutputStream os = new FileOutputStream(destination)) {
+			IOUtils.copy(is, os);
+		} catch (IOException ex) {
+			throw new UncheckedIOException(ex);
+		}
+	}
+
+	private void copyToProject(Mustache view, Map<String, Object> model, File destination) {
+		try (OutputStream os = new FileOutputStream(destination)) {
+			view.execute(new OutputStreamWriter(os), model).flush();
+		} catch (IOException ex) {
+			throw new UncheckedIOException(ex);
+		}
+	}
+
+	private Map<String, Object> hspTemplateValues(String version, File configurationDirectory) {
+		Map<String, Object> values = new LinkedHashMap<>();
+		values.put("version", version);
+		values.put("patchVersion", version.split("\\.")[2]);
+		values.put("relativeTo", "const(THIS_FILE)/" + configurationDirectory.toPath().relativize(this.project.getProjectDir().toPath()));
+
+		List<Map<String, Object>> entries = new ArrayList<>();
+		Set<Project> projects = this.project.getAllprojects();
+		for (Project p : projects) {
+			SourceSetContainer sourceSets = (SourceSetContainer) p.getExtensions().findByName("sourceSets");
+			if (sourceSets == null) {
+				continue;
+			}
+			for (SourceSet source : sourceSets) {
+				Set<File> classDirs = source.getOutput().getClassesDirs().getFiles();
+				for (File directory : classDirs) {
+					Map<String, Object> entry = new HashMap<>();
+					entry.put("path", this.project.getProjectDir().toPath().relativize(directory.toPath()));
+					entry.put("module", p.getName());
+					entries.add(entry);
+				}
+			}
+		}
+		values.put("entries", entries);
+		return values;
+	}
+}

buildSrc/src/main/java/s101/S101Install.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package s101;
+
+import java.io.File;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.TaskAction;
+
+public class S101Install extends DefaultTask {
+	@TaskAction
+	public void install() throws Exception {
+		S101PluginExtension extension = getProject().getExtensions().getByType(S101PluginExtension.class);
+		File installationDirectory = extension.getInstallationDirectory().get();
+		File configurationDirectory = extension.getConfigurationDirectory().get();
+		S101Configurer configurer = new S101Configurer(getProject());
+		configurer.install(installationDirectory, configurationDirectory);
+	}
+
+
+}

buildSrc/src/main/java/s101/S101Plugin.java

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package s101;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.JavaExec;
+
+public class S101Plugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getExtensions().add("s101", new S101PluginExtension(project));
+		project.getTasks().register("s101Install", S101Install.class, this::configure);
+		project.getTasks().register("s101Configure", S101Configure.class, this::configure);
+		project.getTasks().register("s101", JavaExec.class, this::configure);
+	}
+
+	private void configure(S101Install install) {
+		install.setDescription("Installs Structure101 to your filesystem");
+	}
+
+	private void configure(S101Configure configure) {
+		configure.setDescription("Applies a default Structure101 configuration to the project");
+	}
+
+	private void configure(JavaExec exec) {
+		exec.setDescription("Runs Structure101 headless analysis, installing and configuring if necessary");
+		exec.dependsOn("check");
+		Project project = exec.getProject();
+		S101PluginExtension extension = project.getExtensions().getByType(S101PluginExtension.class);
+		exec
+				.workingDir(extension.getInstallationDirectory())
+				.classpath(new File(extension.getInstallationDirectory().get(), "structure101-java-build.jar"))
+				.args(new File(new File(project.getBuildDir(), "s101"), "config.xml"))
+				.systemProperty("s101.label", computeLabel(extension).get())
+				.doFirst((task) -> {
+					installAndConfigureIfNeeded(project);
+					copyConfigurationToBuildDirectory(extension, project);
+				})
+				.doLast((task) -> {
+					copyResultsBackToConfigurationDirectory(extension, project);
+				});
+	}
+
+	private Property<String> computeLabel(S101PluginExtension extension) {
+		boolean hasBaseline = extension.getConfigurationDirectory().get().toPath()
+				.resolve("repository").resolve("snapshots").resolve("baseline").toFile().exists();
+		if (!hasBaseline) {
+			return extension.getLabel().convention("baseline");
+		}
+		return extension.getLabel().convention("recent");
+	}
+
+	private void installAndConfigureIfNeeded(Project project) {
+		S101Configurer configurer = new S101Configurer(project);
+		S101PluginExtension extension = project.getExtensions().getByType(S101PluginExtension.class);
+		String licenseId = extension.getLicenseId().getOrNull();
+		if (licenseId != null) {
+			configurer.license(licenseId);
+		}
+		File installationDirectory = extension.getInstallationDirectory().get();
+		File configurationDirectory = extension.getConfigurationDirectory().get();
+		if (!installationDirectory.exists()) {
+			configurer.install(installationDirectory, configurationDirectory);
+		}
+		if (!configurationDirectory.exists()) {
+			configurer.configure(installationDirectory, configurationDirectory);
+		}
+	}
+
+	private void copyConfigurationToBuildDirectory(S101PluginExtension extension, Project project) {
+		Path configurationDirectory = extension.getConfigurationDirectory().get().toPath();
+		Path buildDirectory = project.getBuildDir().toPath();
+		copyDirectory(project, configurationDirectory, buildDirectory);
+	}
+
+	private void copyResultsBackToConfigurationDirectory(S101PluginExtension extension, Project project) {
+		Path buildConfigurationDirectory = project.getBuildDir().toPath().resolve("s101");
+		String label = extension.getLabel().get();
+		if ("baseline".equals(label)) { // a new baseline was created
+			copyDirectory(project, buildConfigurationDirectory.resolve("repository").resolve("snapshots"),
+					extension.getConfigurationDirectory().get().toPath().resolve("repository"));
+			copyDirectory(project, buildConfigurationDirectory.resolve("repository"),
+					extension.getConfigurationDirectory().get().toPath());
+		}
+	}
+
+	private void copyDirectory(Project project, Path source, Path destination) {
+		try {
+			Files.walk(source)
+					.forEach(each -> {
+						Path relativeToSource = source.getParent().relativize(each);
+						Path resolvedDestination = destination.resolve(relativeToSource);
+						if (each.toFile().isDirectory()) {
+							resolvedDestination.toFile().mkdirs();
+							return;
+						}
+						InputStream input;
+						if ("project.java.hsp".equals(each.toFile().getName())) {
+							Path relativeTo = project.getBuildDir().toPath().resolve("s101").relativize(project.getProjectDir().toPath());
+							String value = "const(THIS_FILE)/" + relativeTo;
+							input = replace(each, "<property name=\"relative-to\" value=\"(.*)\" />", "<property name=\"relative-to\" value=\"" + value + "\" />");
+						} else if (each.toFile().toString().endsWith(".xml")) {
+							input = replace(each, "\\r\\n", "\n");
+						} else {
+							input = input(each);
+						}
+						try {
+							Files.copy(input, resolvedDestination, StandardCopyOption.REPLACE_EXISTING);
+						} catch (IOException e) {
+							throw new RuntimeException(e);
+						}
+					});
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private InputStream replace(Path file, String search, String replace) {
+		try {
+			byte[] b = Files.readAllBytes(file);
+			String contents = new String(b).replaceAll(search, replace);
+			return new ByteArrayInputStream(contents.getBytes(StandardCharsets.UTF_8));
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private InputStream input(Path file) {
+		try {
+			return new FileInputStream(file.toFile());
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+}

buildSrc/src/main/java/s101/S101PluginExtension.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2002-2021 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package s101;
+
+import java.io.File;
+
+import org.gradle.api.Project;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputDirectory;
+
+public class S101PluginExtension {
+	private final Property<String> licenseId;
+	private final Property<File> installationDirectory;
+	private final Property<File> configurationDirectory;
+	private final Property<String> label;
+
+	@Input
+	public Property<String> getLicenseId() {
+		return this.licenseId;
+	}
+
+	public void setLicenseId(String licenseId) {
+		this.licenseId.set(licenseId);
+	}
+
+	@InputDirectory
+	public Property<File> getInstallationDirectory() {
+		return this.installationDirectory;
+	}
+
+	public void setInstallationDirectory(String installationDirectory) {
+		this.installationDirectory.set(new File(installationDirectory));
+	}
+
+	@InputDirectory
+	public Property<File> getConfigurationDirectory() {
+		return this.configurationDirectory;
+	}
+
+	public void setConfigurationDirectory(String configurationDirectory) {
+		this.configurationDirectory.set(new File(configurationDirectory));
+	}
+
+	@Input
+	public Property<String> getLabel() {
+		return this.label;
+	}
+
+	public void setLabel(String label) {
+		this.label.set(label);
+	}
+
+	public S101PluginExtension(Project project) {
+		this.licenseId = project.getObjects().property(String.class);
+		if (project.hasProperty("s101.licenseId")) {
+			setLicenseId((String) project.findProperty("s101.licenseId"));
+		}
+		this.installationDirectory = project.getObjects().property(File.class)
+				.convention(new File(project.getBuildDir(), "s101"));
+		this.configurationDirectory = project.getObjects().property(File.class)
+				.convention(new File(project.getProjectDir(), "s101"));
+		this.label = project.getObjects().property(String.class);
+		if (project.hasProperty("s101.label")) {
+			setLabel((String) project.findProperty("s101.label"));
+		}
+	}
+}

buildSrc/src/main/java/trang/RncToXsd.java

@@ -0,0 +1,83 @@
+package trang;
+
+import com.thaiopensource.relaxng.translate.Driver;
+import net.sf.saxon.TransformerFactoryImpl;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.InputDirectory;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.TaskAction;
+
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+/**
+ * Converts .rnc files to .xsd files using trang and then applies an xsl file to cleanup the results.
+ */
+public class RncToXsd extends DefaultTask {
+
+	private File rncDir;
+
+	private File xslFile;
+
+	private File xsdDir;
+
+	@InputDirectory
+	public File getRncDir() {
+		return rncDir;
+	}
+
+	public void setRncDir(File rncDir) {
+		this.rncDir = rncDir;
+	}
+
+	@InputFile
+	public File getXslFile() {
+		return xslFile;
+	}
+
+	public void setXslFile(File xslFile) {
+		this.xslFile = xslFile;
+	}
+
+	@OutputDirectory
+	public File getXsdDir() {
+		return xsdDir;
+	}
+
+	public void setXsdDir(File xsdDir) {
+		this.xsdDir = xsdDir;
+	}
+
+	@TaskAction
+	public final void transform() throws IOException, TransformerException {
+		String xslPath = xslFile.getAbsolutePath();
+
+		File[] files = rncDir.listFiles((dir, file) -> file.endsWith(".rnc"));
+		if(files != null) {
+			for (File rncFile : files) {
+				File xsdFile = new File(xsdDir, rncFile.getName().replace(".rnc", ".xsd"));
+				String xsdOutputPath = xsdFile.getAbsolutePath();
+
+				new Driver().run(new String[]{rncFile.getAbsolutePath(), xsdOutputPath});
+
+				TransformerFactory tFactory = new TransformerFactoryImpl();
+				Transformer transformer = tFactory.newTransformer(new StreamSource(xslPath));
+
+				File temp = File.createTempFile("gradle-trang-" + xsdFile.getName(), ".xsd");
+
+				Files.copy(xsdFile.toPath(), temp.toPath(), StandardCopyOption.REPLACE_EXISTING);
+				StreamSource xmlSource = new StreamSource(temp);
+				transformer.transform(xmlSource, new StreamResult(xsdFile));
+				temp.delete();
+			}
+		}
+	}
+}

buildSrc/src/main/java/trang/TrangPlugin.java

@@ -0,0 +1,18 @@
+package trang;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+/**
+ * Used for converting .rnc files to .xsd files.
+ * @author Rob Winch
+ */
+public class TrangPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getTasks().register("rncToXsd", RncToXsd.class, (rncToXsd) -> {
+			rncToXsd.setDescription("Converts .rnc to .xsd");
+			rncToXsd.setGroup("Build");
+		});
+	}
+}

buildSrc/src/main/resources/META-INF/gradle-plugins/io.spring.convention.artifactory.properties

@@ -0,0 +1 @@
+implementation-class=io.spring.gradle.convention.ArtifactoryPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/io.spring.convention.bom.properties

@@ -0,0 +1 @@
+implementation-class=io.spring.gradle.convention.MavenBomPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/io.spring.convention.checkstyle.properties

@@ -0,0 +1 @@
+implementation-class=io.spring.gradle.convention.CheckstylePlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/io.spring.convention.docs.properties

@@ -0,0 +1 @@
+implementation-class=io.spring.gradle.convention.DocsPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/io.spring.convention.include-check-remote.properties

@@ -0,0 +1 @@
+implementation-class=io.spring.gradle.convention.IncludeCheckRemotePlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/io.spring.convention.integration-test.properties

@@ -0,0 +1 @@
+implementation-class=io.spring.gradle.convention.IntegrationTestPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/io.spring.convention.jacoco.properties

@@ -0,0 +1 @@
+implementation-class=io.spring.gradle.convention.JacocoPlugin