Release 2.7.1

Closes gh-2264

.editorconfig

@@ -0,0 +1,19 @@
+root = true
+
+[*]
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 120
+
+[*.java]
+indent_style = tab
+indent_size = 4
+charset = latin1
+continuation_indent_size = 8
+
+[*.xml]
+indent_style = tab
+indent_size = 4
+charset = latin1
+continuation_indent_size = 8

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,17 @@
+<!--
+!!! For Security Vulnerabilities, please go to https://spring.io/security-policy !!!
+-->
+**Affects:** \<Spring Framework version>
+
+---
+<!--
+Thanks for taking the time to create an issue. Please read the following:
+
+- Questions should be asked on Stack Overflow.
+- For bugs, specify affected versions and explain what you are trying to do.
+- For enhancements, provide context and describe the problem.
+
+Issue or Pull Request? Create only one, not both. GitHub treats them as the same.
+If unsure, start with an issue, and if you submit a pull request later, the
+issue will be closed as superseded.
+-->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,24 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: 'type: bug, status: waiting-for-triage'
+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-session
+    about: Please ask and answer questions on StackOverflow with the tag spring-session

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,25 @@
+---
+name: Feature request
+about: Suggest an idea 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,7 @@
+<!--
+For Security Vulnerabilities, please use https://pivotal.io/security#reporting
+-->
+
+<!--
+Thanks for contributing to Spring Session. Please provide a brief description of your pull-request and reference any related issue numbers (prefix references with #).
+-->

.github/actions/algolia-config.json

@@ -0,0 +1,20 @@
+{
+  "index_name": "session-docs",
+  "start_urls": [
+    "https://docs.spring.io/spring-session/reference/"
+  ],
+  "selectors": {
+    "lvl0": {
+      "selector": "//nav[@class='crumbs']//li[@class='crumb'][last()-1]",
+      "type": "xpath",
+      "global": true,
+      "default_value": "Home"
+    },
+    "lvl1": ".doc h1",
+    "lvl2": ".doc h2",
+    "lvl3": ".doc h3",
+    "lvl4": ".doc h4",
+    "text": ".doc p, .doc td.content, .doc th.tableblock"
+  }
+}
+

.github/actions/algolia-deploy.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+HOST="$1"
+HOST_PATH="$2"
+SSH_PRIVATE_KEY="$3"
+SSH_KNOWN_HOST="$4"
+
+
+if [ "$#" -ne 4 ]; then
+  echo -e "not enough arguments USAGE:\n\n$0 \$HOST \$HOST_PATH \$SSH_PRIVATE_KEY \$SSH_KNOWN_HOSTS \n\n" >&2
+  exit 1
+fi
+
+# Use a non-default path to avoid overriding when testing locally
+SSH_PRIVATE_KEY_PATH=~/.ssh/github-actions-docs
+install -m 600 -D /dev/null "$SSH_PRIVATE_KEY_PATH"
+echo "$SSH_PRIVATE_KEY" > "$SSH_PRIVATE_KEY_PATH"
+echo "$SSH_KNOWN_HOST" > ~/.ssh/known_hosts
+rsync --delete -avze "ssh -i $SSH_PRIVATE_KEY_PATH" spring-session-docs/build/site/ "$HOST:$HOST_PATH"
+rm -f "$SSH_PRIVATE_KEY_PATH"

.github/actions/algolia-docsearch-scraper.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+###
+# Docs
+# config.json https://docsearch.algolia.com/docs/config-file
+# Run the crawler https://docsearch.algolia.com/docs/run-your-own/#run-the-crawl-from-the-docker-image
+
+### USAGE
+if [ "$#" -ne 3 ]; then
+  echo -e "not enough arguments USAGE:\n\n$0 \$ALGOLIA_APPLICATION_ID \$ALGOLIA_API_KEY \$CONFIG_FILE\n\n" >&2
+  exit 1
+fi
+
+# Script Parameters
+APPLICATION_ID=$1
+API_KEY=$2
+CONFIG_FILE=$3
+
+#### Script
+script_dir=$(dirname $0)
+docker run -e "APPLICATION_ID=$APPLICATION_ID" -e "API_KEY=$API_KEY" -e "CONFIG=$(cat $CONFIG_FILE | jq -r tostring)" algolia/docsearch-scraper

.github/actions/dispatch.sh

@@ -0,0 +1,5 @@
+REPOSITORY_REF="$1"
+TOKEN="$2"
+
+curl -H "Accept: application/vnd.github.everest-preview+json" -H "Authorization: token ${TOKEN}" --request POST  --data '{"event_type": "request-build-reference"}' https://api.github.com/repos/${REPOSITORY_REF}/dispatches
+echo "Requested Build for $REPOSITORY_REF"

.github/workflows/algolia-index.yml

@@ -0,0 +1,16 @@
+name: Update Algolia Index
+
+on:
+  schedule:
+    - cron: '0 10 * * *' # Once per day at 10am UTC
+  workflow_dispatch: # Manual trigger
+
+jobs:
+  update:
+    name: Update Algolia Index
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Source
+        uses: actions/checkout@v2
+      - name: Update Index
+        run: ${GITHUB_WORKSPACE}/.github/actions/algolia-docsearch-scraper.sh "${{ secrets.ALGOLIA_APPLICATION_ID }}" "${{ secrets.ALGOLIA_WRITE_API_KEY }}" "${GITHUB_WORKSPACE}/.github/actions/algolia-config.json"

.github/workflows/antora-generate.yml

@@ -0,0 +1,31 @@
+name: Generate Antora Files and Request Build
+
+on:
+  workflow_dispatch:  # Manual trigger
+  push:
+    branches-ignore:
+      - 'gh-pages'
+
+env:
+  GH_ACTIONS_REPO_TOKEN: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Source
+        uses: actions/checkout@v2
+      - name: Generate antora.yml
+        run: ./gradlew :spring-session-docs:generateAntora
+      - name: Extract Branch Name
+        id: extract_branch_name
+        run: echo "##[set-output name=generated_branch_name;]$(echo ${GITHUB_REPOSITORY}/${GITHUB_REF##*/})"
+      - name: Push generated antora files to the spring-generated-docs
+        uses: JamesIves/github-pages-deploy-action@4.1.4
+        with:
+          branch:  ${{ steps.extract_branch_name.outputs.generated_branch_name }} # The branch the action should deploy to.
+          folder: "spring-session-docs/build/generateAntora" # The folder the action should deploy.
+          repository-name: "spring-io/spring-generated-docs"
+          token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+      - name: Dispatch Build Request
+        run: ${GITHUB_WORKSPACE}/.github/actions/dispatch.sh 'spring-projects/spring-session' "$GH_ACTIONS_REPO_TOKEN"

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

@@ -0,0 +1,98 @@
+name: CI
+
+on:
+  push:
+  schedule:
+    - cron: '0 10 * * *' # Once per day at 10am UTC
+  workflow_dispatch: # Manual trigger
+
+env:
+  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 }}
+  ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+  ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    if: github.repository == 'spring-projects/spring-session'
+    strategy:
+      matrix:
+        jdk: [8, 11]
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK ${{ matrix.jdk }}
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.jdk }}
+      - name: Setup gradle user name
+        run: |
+          mkdir -p ~/.gradle
+          echo 'systemProp.user.name=spring-builds+github' >> ~/.gradle/gradle.properties
+      - name: Cache Gradle packages
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+      - name: Build with Gradle
+        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 clean build -PartifactoryUsername="$ARTIFACTORY_USERNAME" -PartifactoryPassword="$ARTIFACTORY_PASSWORD" --no-daemon --stacktrace
+  artifacts:
+    name: Deploy Artifacts
+    needs: [build]
+    runs-on: ubuntu-latest
+    if: github.repository == 'spring-projects/spring-session'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK
+        uses: actions/setup-java@v1
+        with:
+          java-version: '8'
+      - 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 }}
+  docs:
+    name: Deploy Docs
+    needs: [build]
+    runs-on: ubuntu-latest
+    if: github.repository == 'spring-projects/spring-session'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK
+        uses: actions/setup-java@v1
+        with:
+          java-version: '8'
+      - name: Setup gradle user name
+        run: |
+          mkdir -p ~/.gradle
+          echo 'systemProp.user.name=spring-builds+github' >> ~/.gradle/gradle.properties
+      - name: Deploy Docs
+        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 deployDocs --no-daemon -PdeployDocsSshKey="$DOCS_SSH_KEY" -PdeployDocsSshUsername="$DOCS_USERNAME" -PdeployDocsHost="$DOCS_HOST" --stacktrace
+        env:
+          DOCS_USERNAME: ${{ secrets.DOCS_USERNAME }}
+          DOCS_SSH_KEY: ${{ secrets.DOCS_SSH_KEY }}
+          DOCS_HOST: ${{ secrets.DOCS_HOST }}

.github/workflows/deploy-reference.yml

@@ -0,0 +1,33 @@
+name: Build & Deploy Reference
+
+on:
+  repository_dispatch:
+    types: request-build-reference
+  schedule:
+    - cron: '0 10 * * *' # Once per day at 10am UTC
+  workflow_dispatch: # Manual trigger
+
+jobs:
+  deploy:
+    name: deploy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v2
+        with:
+          java-version: '11'
+          distribution: 'adopt'
+          cache: gradle
+      - name: Validate Gradle wrapper
+        uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
+      - name: Build with Gradle
+        run: ./gradlew :spring-session-docs:antora --stacktrace
+      - name: Cleanup Gradle Cache
+        # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions.
+        # Restoring these files from a GitHub Actions cache might cause problems for future builds.
+        run: |
+          rm -f ~/.gradle/caches/modules-2/modules-2.lock
+          rm -f ~/.gradle/caches/modules-2/gc.properties
+      - name: Deploy
+        run: ${GITHUB_WORKSPACE}/.github/actions/algolia-deploy.sh "${{ secrets.DOCS_USERNAME }}@${{ secrets.DOCS_HOST }}" "/opt/www/domains/spring.io/docs/htdocs/spring-session/reference/" "${{ secrets.DOCS_SSH_KEY }}" "${{ secrets.DOCS_SSH_HOST_KEY }}"

.github/workflows/gradle-wrapper-validation.yml

@@ -0,0 +1,10 @@
+name: "Validate Gradle Wrapper"
+on: [push, pull_request]
+
+jobs:
+  validation:
+    name: "Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: gradle/wrapper-validation-action@v1

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

@@ -0,0 +1,26 @@
+name: PR Build
+
+on: pull_request
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    if: github.repository == 'spring-projects/spring-session'
+    strategy:
+      matrix:
+        jdk: [8, 11]
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK ${{ matrix.jdk }}
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.jdk }}
+      - name: Cache Gradle packages
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+      - name: Build with Gradle
+        run: ./gradlew clean build --no-daemon --stacktrace

.gitignore

@@ -7,4 +7,10 @@ bin
 .settings
 .project
 target
-out
+out
+.springBeans
+*.rdb
+.checkstyle
+!etc/eclipse/.checkstyle
+!**/src/**/build
+.DS_Store

.sdkmanrc

@@ -0,0 +1,6 @@
+# Use sdkman to run "sdk env" to initialize with correct JDK version
+# Enable auto-env through the sdkman_auto_env config
+# See https://sdkman.io/usage#config
+# A summary is to add the following to ~/.sdkman/etc/config
+# sdkman_auto_env=true
+java=8.0.332-zulu

CONTRIBUTING.adoc

@@ -0,0 +1,39 @@
+= Contributing to Spring Session
+
+Spring Session is released under the Apache 2.0 license. If you would like to contribute
+something, or simply want to hack on the code this document should help you get started.
+
+
+== Code of Conduct
+
+Please see our https://github.com/spring-projects/.github/blob/main/CODE_OF_CONDUCT.md[code of conduct].
+
+
+== Reporting Security Vulnerabilities
+
+Please see our https://github.com/spring-projects/spring-session/security/policy[Security policy].
+
+
+== Using GitHub issues
+
+We use GitHub issues to track bugs and enhancements. If you have a general usage question
+please ask on https://stackoverflow.com[Stack Overflow]. The Spring Session team and the
+broader community monitor the https://stackoverflow.com/tags/spring-session[`spring-session`]
+tag.
+
+If you are reporting a bug, please help to speed up problem diagnosis by providing as much
+information as possible. Ideally, that would include a small sample project that
+reproduces the problem.
+
+== Create your branch from the oldest maintenance branch
+
+Create your topic branch to be submitted as a pull request from the oldest impacted and supported maintenance branch.
+You can find the supported versions by looking at the https://github.com/spring-projects/spring-session/milestones[milestones page].
+Switch to a branch named `<major>.<minor>.x` from the smallest milestone in the format of `<major>.<minor>.<patch>(-<prerelease>)`.
+The spring team will ensure the code gets merged forward into additional branches.
+
+
+== Sign the Contributor License Agreement
+If you have not previously done so, please fill out and
+submit the https://cla.pivotal.io/sign/spring[Contributor License Agreement].
+

LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

README.adoc

@@ -1,191 +1,74 @@
 = Spring Session
-Rob Winch
-1.0.0.BUILD-SNAPSHOT
-:toc:
-:toc-placement: preamble
-:sectanchors:
-:icons: font
-:source-highlighter: prettify
-:idseparator: -
-:idprefix:
-:doctype: book
-:spring-session-version: 1.0.0.BUILD-SNAPSHOT
 
-Spring Session aims to provide a common infrastructure for managing sessions. This allows for:
+image:https://badges.gitter.im/spring-projects/spring-session.svg[link="https://gitter.im/spring-projects/spring-session?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"]
 
-* Accessing a session from any environment (i.e. web, messaging infrastructure, etc)
-* In a web environment
-** Support for clustering in a vendor neutral way
-** Pluggable strategy for determining the session id
-** Easily keep the HttpSession alive when a WebSocket is active
+image:https://github.com/spring-projects/spring-session/workflows/CI/badge.svg?branch=main["Build Status", link="https://github.com/spring-projects/spring-session/actions?query=workflow%3ACI"]
 
-= Quick Start
+Spring Session provides an API and implementations for managing a user's session information, while also making it trivial to support clustered sessions without being tied to an application container specific solution.
+It also provides transparent integration with:
 
-This section describes how to use Spring Session to use Redis when interacting with a web application's HttpSession. If you'd like to skip the reading, you can also refer to the <<sample>>
+* `HttpSession` - allows replacing the `HttpSession` in an application container (i.e. Tomcat) neutral way, with support for providing session IDs in headers to work with RESTful APIs.
+* `WebSocket` - provides the ability to keep the `HttpSession` alive when receiving WebSocket messages
+* `WebSession` - allows replacing the Spring WebFlux's `WebSession` in an application container neutral way.
 
-== Updating Dependencies
-Before you use the project, you must ensure to update your dependencies. Instructions for building with Maven and Gradle have been provided below:
+== Modules
 
- * <<building-with-maven>>
- * <<building-with-gradle>>
+This Spring Session repository consists of the following modules:
 
-=== Building with Maven
+* Spring Session Core - provides core Spring Session functionalities and APIs
+* Spring Session Data Redis - provides `SessionRepository` and `ReactiveSessionRepository` implementation backed by Redis and configuration support
+* Spring Session JDBC - provides `SessionRepository` implementation backed by a relational database and configuration support
+* Spring Session Hazelcast - provides `SessionRepository` implementation backed by Hazelcast and configuration support
+* Spring Session MongoDB - provides `SessionRepository` implementation backed by MongoDB and configuration support
 
-The project is available in the https://github.com/spring-projects/spring-framework/wiki/SpringSource-repository-FAQ[Spring Maven Repository]. If you are using Maven, you will want to make the following updates.
+Additional Spring Session modules can be found in the https://github.com/spring-projects/spring-session-data-geode[spring-session-data-geode] repository.
 
-**Using the latest Snapshot in Maven**
+== Getting Started
 
-If you want the latest snapshot, ensure you have the following repository in your pom.xml:
+We recommend you visit the https://docs.spring.io/spring-session/reference/index.html[Spring Session Reference] and look through the "Samples and Guides" section to see which one best suits your needs.
 
-[source,xml]
+== Samples
+
+Spring Session samples are available in the https://github.com/spring-projects/spring-session/tree/main/spring-session-samples[spring-session-samples] directory.
+
+
+== Contributing
+
+Please see our https://github.com/spring-projects/spring-session/blob/main/CONTRIBUTING.adoc[Contributing guidelines]
+for information on how to report issues, enhancements or security vulnerabilities.
+
+== Building from Source
+
+Spring Session uses a https://gradle.org[Gradle]-based build system.
+In the instructions below, `./gradlew` is invoked from the root of the source tree and serves as
+a cross-platform, self-contained bootstrap mechanism for the build.
+
+Check out sources
 ----
-<repository>
-  <id>spring-snapshot</id>
-  <url>https://repo.spring.io/libs-snapshot</url>
-</repository>
+git clone git@github.com:spring-projects/spring-session.git
 ----
 
-Then ensure you have added the dependency:
-
-[source,xml]
-[subs="verbatim,attributes"]
+Install all spring-\* jars into your local Maven cache
 ----
-<dependency>
-  <groupId>org.springframework.session</groupId>
-  <artifactId>spring-session</artifactId>
-  <version>{spring-session-version}</version>
-</dependency>
-<dependency>
-  <groupId>org.springframework</groupId>
-  <artifactId>spring-web</artifactId>
-  <version>{spring-version}</version>
-</dependency>
-<dependency>
-  <groupId>org.springframework.data</groupId>
-  <artifactId>spring-data-redis</artifactId>
-  <version>1.3.0.RELEASE</version>
-</dependency>
-<dependency>
-  <groupId>redis.clients</groupId>
-  <artifactId>jedis</artifactId>
-  <version>2.4.1</version>
-</dependency>
-<dependency>
-  <groupId>org.apache.commons</groupId>
-  <artifactId>commons-pool2</artifactId>
-  <version>2.2</version>
-</dependency>
+./gradlew install
 ----
 
-=== Building with Gradle
-
-**Using the latest Snapshot in Gradle**
-
-If you want the latest snapshot, ensure you have the following repository in your pom.xml:
-
-[source,groovy]
+Compile and test; build all jars, distribution zips, and docs
 ----
-repositories {
-  maven { url 'https://repo.spring.io/libs-snapshot' }
-}
+./gradlew build
 ----
 
-Then ensure you have added the dependency:
 
-[source,groovy]
-[subs="verbatim,attributes"]
-----
-dependencies {
-  compile "org.springframework.session:spring-session:{spring-session-version}",
-          "org.springframework:spring-web:{spring-version}",
-          "org.springframework.data:spring-data-redis:1.3.0.RELEASE",
-          "redis.clients:jedis:2.4.1",
-          "org.apache.commons:commons-pool2:2.2"
-}
-----
+== Documentation
 
-== Spring Configuration
+You can find the documentation, samples, and guides for using Spring Session on the https://projects.spring.io/spring-session/[Spring Session project site].
 
-Add the following Spring Configuration:
+For more in depth information, visit the https://docs.spring.io/spring-session/docs/current/reference/html5/[Spring Session Reference].
 
-[source,java]
-----
-@Configuration
-public class Config {
+== Code of Conduct
 
-	@Bean
-	public JedisConnectionFactory connectionFactory() throws Exception {
-		return new JedisConnectionFactory();
-	}
+Please see our https://github.com/spring-projects/.github/blob/main/CODE_OF_CONDUCT.md[code of conduct].
 
-	@Bean
-	public RedisTemplate<String,Session> redisTemplate(RedisConnectionFactory connectionFactory) {
-		RedisTemplate<String, Session> template = new RedisTemplate<String, Session>();
-		template.setKeySerializer(new StringRedisSerializer());
-		template.setHashKeySerializer(new StringRedisSerializer());
-		template.setConnectionFactory(connectionFactory);
-		return template;
-	}
+== License
 
-	@Bean
-	public RedisOperationsSessionRepository sessionRepository(RedisTemplate<String, Session> redisTemplate) {
-		return new RedisOperationsSessionRepository(redisTemplate);
-	}
-
-	@Bean
-	public SessionRepositoryFilter sessionFilter(RedisOperationsSessionRepository sessionRepository) {
-		return new SessionRepositoryFilter(sessionRepository);
-	}
-}
-----
-
-In our example, we are connecting to the default port (6379). For more information on configuring Spring Data Redis, refer to the http://docs.spring.io/spring-data/data-redis/docs/current/reference/html/[reference documentation].
-
-== Servlet Initialization
-
-We next need to be sure our Servlet Container (i.e. Tomcat) is properly configured.
-
-. First we need ensure that our `Config` class from above was loaded. In the example below we do this by extending `AbstractContextLoaderInitializer` and implementing `createRootApplicationContext`.
-. Next we need to be sure the `SessionRepositoryFilter` is regsitered with the Servlet Container. We can do this by mapping a `DelegatingFilterProxy` to every request with the same name as the bean name of our `SessionRepositoryFilter`. In our instance, the bean name is the method name we used to create our `SessionRepositoryFilter`.
-
-[source,java]
-----
-public class Initializer extends AbstractContextLoaderInitializer {
-	@Override
-	public void onStartup(ServletContext servletContext) throws ServletException {
-		super.onStartup(servletContext);
-		servletContext.addFilter("sessionFilter", DelegatingFilterProxy.class)
-				.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, "/*");
-	}
-
-	@Override
-	protected WebApplicationContext createRootApplicationContext() {
-		AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
-		context.register(Config.class);
-		return context;
-	}
-}
-----
-
-= Sample
-
-The code contains a https://github.com/spring-projects/spring-session/tree/master/samples/web[sample web application]. To run the sample:
-
-. Obtain the source by https://github.com/spring-projects/spring-session[cloning the repository] or https://github.com/spring-projects/spring-session/archive/master.zip[downloading] it.
-. Run the application using gradle
-.. Linux / OSX `./gradlew tomcatRun`
-.. Windows `.\gradlew.bat tomcatRun`
-. Visit http://localhost:8080/
-
-= Benefits
-
-* This can make clustering much easier. This is nice because the clustering setup is done in a vendor neutral way. Furthermore, in some environments (i.e. PaaS solutions) developers cannot modify the cluster settings easily.
-* We can use different strategies for determining the session id. This gives us at least a few benefits
-** Allowing for a single browser to have multiple simultaneous sessions in a transparent fashion. For example, many developers wish to allow a user to authenticate with multiple accounts and switch between them similar to how you can in gmail.
-** When using a REST API, the session can be specified using a header instead of the JSESSIONID cookie (which leaks implementation details to the client). Many would argue that session is bad in REST because it has state, but it is important to note that session is just a form of cache and used responsibly it will increase performance & security.
-** When a session id is acquired in a header, we can default CSRF protection to off. This is because if the session id is found in the header we know that it is impossible to be a CSRF attack since, unlike cookies, headers must be manually populated.
-* We can easily keep the HttpSession and WebSocket Session in sync. Imagine a web application like gmail where you can authenticate and either write emails (HTTP requests) or chat (WebSocket). In standard servlet environment there is no way to keep the HttpSession alive through the WebSocket so you must ping the server. With our own session strategy we can have the WebSocket messages automatically keep the HttpSession alive. We can also destroy both sessions at once easily.
-* We can provide hooks to allow users to invalidate sessions that should not be active. For example, if you look in the lower right of gmail you can see the last account activity and click "Details". This shows a listing of all the active sessions along with the IP address, location, and browser information for your account.
-** Users can look through this and determine if anything is suspicious (i.e. if their account has a session that is associated to a country they have never been) and invalidate that session and change their password.
-** Another useful example is perhaps they checked their mail at the library and forgot to log out. With this custom mechanism this is very possible.
-* Spring Security currently supports restricting the number of concurrent sessions each user can have. The implementation works, but does so passively since we cannot get a handle to the session from the session id. Specifically, each time a user requests a page we check to see if that session id is valid in a separate data store. If it is no longer valid, we invalidate the session. With this new mechanism we can invalidate the session from the session id.
+Spring Session is Open Source software released under the https://www.apache.org/licenses/LICENSE-2.0.html[Apache 2.0 license].

RELEASE.adoc

@@ -0,0 +1,110 @@
+== 1. Update Dependencies
+
+Dependencies are declared in `gradle/dependency-management.gradle`.
+Update Spring Framework, Spring Security and Spring Data at a minimum.
+
+Run all the checks:
+
+[source,bash]
+----
+$ ./gradlew check
+----
+
+Create separate issues for each dependency update, aside from test dependencies which can be combined into a single commit.
+
+== 2. Check All Issues are Closed
+
+You can manually check at https://github.com/spring-projects/spring-session/milestones
+
+== 3. Update Release Version
+
+Update the version number in `gradle.properties` for the release, for example `2.7.0-M1`, `2.7.0-RC1`, `2.7.3`
+
+== 4. Update Antora Version
+
+You will need to update the antora.yml version.
+
+For milestone / release candidate releases you should follow this format:
+----
+version: '2.7.0-RC1'
+prerelease: 'true'
+display_version: '2.7.0-RC1'
+----
+
+== 5. Build Locally
+
+Run the build using
+
+[source,bash]
+----
+$ ./gradlew check
+----
+
+== 6. Push the Release Commit
+
+Push the commit and GitHub actions will build and deploy the artifacts.
+Wait for the artifact to appear in https://repo1.maven.org/maven2/org/springframework/session/spring-session-core/
+
+== 7. Tag the release
+
+Tag the release and then push the tag
+
+....
+git tag 2.7.0-RC1
+git push origin 2.7.0-RC1
+....
+
+== 8. Update to Next Development Version
+
+Update `gradle.properties` version to next `+SNAPSHOT+` version, update antora.yml and then push
+
+== 9. Update version on project pages
+
+Update the versions on https://spring.io/projects for Spring Session Core, Spring Session Data Redis, Spring Session JDBC, Spring Session Hazelcast, and Spring Session MongoDB.
+
+== 10. Update Release Notes on GitHub
+
+Download
+https://github.com/spring-io/github-changelog-generator/releases/latest[the
+GitHub release notes generator]
+
+* Generate the release notes
+
+....
+java -jar github-changelog-generator.jar \
+    --changelog.repository=spring-projects/spring-session \
+    $MILESTONE release-notes
+....
+
+Note 1: `+$MILESTONE+` is something like `+2.7.1+` or `+2.7.0-M1+`. +
+Note 2: This will create a file on your filesystem
+called `+release-notes+`.
+
+* Copy the release notes to your clipboard (your mileage may vary with
+the following command)
+
+....
+cat release-notes | xclip -selection clipboard
+....
+
+* Create the
+https://github.com/spring-projects/spring-session/releases[release on
+GitHub], associate it with the tag, and paste the generated notes.
+
+== 11. Close / Create Milestone
+
+* In
+https://github.com/spring-projects/spring-session/milestones[GitHub
+Milestones], create a new milestone for the next release version.
+* Move any open issues from the existing milestone you just released to
+the new milestone.
+* Close the milestone for the release.
+
+Note: Spring Session typically releases only one milestone (M1) and one release candidate (RC1).
+
+== 12. Announce the release
+
+* Announce via Slack on https://pivotal.slack.com/messages/spring-session[#spring-session], and tag any downstream Spring Session projects (e.g Spring Session for Apache Geode).
+
+Note: Do not post on #spring-release or create a blog post. Those steps happen after the Spring Session BOM is released.
+

build.gradle

@@ -1,35 +1,48 @@
 buildscript {
-    repositories {
-        maven { url "https://repo.spring.io/plugins-release" }
-    }
-    dependencies {
-        classpath("org.gradle.api.plugins:gradle-tomcat-plugin:1.2.3")
-        classpath("org.springframework.build.gradle:propdeps-plugin:0.0.6")
-        classpath("org.springframework.build.gradle:spring-io-plugin:0.0.3.RELEASE")
-        classpath('me.champeau.gradle:gradle-javadoc-hotfix-plugin:0.1')
-        classpath('org.asciidoctor:asciidoctor-gradle-plugin:0.7.0')
-        classpath('org.asciidoctor:asciidoctor-java-integration:0.1.4.preview.1')
-    }
+	ext {
+		releaseBuild = version.endsWith('RELEASE')
+		snapshotBuild = version.endsWith('SNAPSHOT')
+		milestoneBuild = !(releaseBuild || snapshotBuild)
+
+		springBootVersion = '2.7.8'
+	}
+
+	repositories {
+		gradlePluginPortal()
+		maven { url 'https://repo.spring.io/plugins-release/' }
+        maven {
+            url = 'https://repo.spring.io/plugins-snapshot'
+            if (project.hasProperty('artifactoryUsername')) {
+                credentials {
+                    username "$artifactoryUsername"
+                    password "$artifactoryPassword"
+                }
+            }
+        }
+	}
+
+	dependencies {
+		classpath "org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion"
+	}
 }
 
+apply plugin: 'io.spring.convention.root'
+
 group = 'org.springframework.session'
+description = 'Spring Session'
 
-ext.JAVA_GRADLE = "$rootDir/gradle/java.gradle"
-ext.TOMCAT_GRADLE = "$rootDir/gradle/tomcat.gradle"
+subprojects {
+	apply plugin: 'io.spring.javaformat'
 
-apply plugin: 'sonar-runner'
+	plugins.withType(JavaPlugin) {
+		sourceCompatibility = JavaVersion.VERSION_1_8
+	}
 
+	tasks.withType(Test) {
+		useJUnitPlatform()
+	}
+}
 
-sonarRunner {
-    sonarProperties {
-        property "sonar.java.coveragePlugin", "jacoco"
-        property "sonar.projectName", "Spring Session"
-        property "sonar.jacoco.reportPath", "${buildDir.name}/jacoco.exec"
-        property "sonar.links.homepage", 'https://github.com/spring-projects/spring-session'
-        property "sonar.links.ci", 'https://build.spring.io/browse/SESSION'
-        property "sonar.links.issue", 'https://github.com/spring-projects/spring-session/issues'
-        property "sonar.links.scm", 'https://github.com/spring-projects/spring-session'
-        property "sonar.links.scm_dev", 'https://github.com/spring-projects/spring-session.git'
-        property "sonar.java.coveragePlugin", "jacoco"
-    }
-}
+nohttp {
+    source.exclude "buildSrc/build/**"
+}

buildSrc/build.gradle

@@ -0,0 +1,87 @@
+plugins {
+    id "java-gradle-plugin"
+    id "java"
+    id "groovy"
+}
+
+sourceCompatibility = 1.8
+
+repositories {
+    jcenter()
+    gradlePluginPortal()
+    mavenCentral()
+    maven { url 'https://repo.spring.io/plugins-release/' }
+}
+
+sourceSets {
+    main {
+        java {
+            srcDirs = []
+        }
+        groovy {
+            srcDirs += ["src/main/java"]
+        }
+    }
+}
+
+gradlePlugin {
+    plugins {
+        managementConfiguration {
+            id = "io.spring.convention.management-configuration"
+            implementationClass = "io.spring.gradle.convention.ManagementConfigurationPlugin"
+        }
+        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"
+        }
+        propdeps {
+            id = "org.springframework.propdeps"
+            implementationClass = "org.springframework.gradle.propdeps.PropDepsPlugin"
+        }
+    }
+}
+
+configurations {
+    implementation {
+        exclude module: 'groovy-all'
+    }
+}
+
+dependencies {
+    implementation 'com.google.code.gson:gson:2.8.8'
+    implementation 'net.sourceforge.saxon:saxon:9.1.0.8'
+    implementation localGroovy()
+
+    implementation 'io.github.gradle-nexus:publish-plugin:1.1.0'
+    implementation 'io.spring.gradle:dependency-management-plugin:1.0.10.RELEASE'
+    implementation 'io.projectreactor:reactor-core:3.4.11'
+    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.10'
+    implementation 'io.spring.javaformat:spring-javaformat-gradle-plugin:0.0.15'
+    implementation 'io.spring.nohttp:nohttp-gradle:0.0.9'
+    implementation 'net.sourceforge.htmlunit:htmlunit:2.55.0'
+    implementation 'org.hidetake:gradle-ssh-plugin:2.10.1'
+    implementation 'org.jfrog.buildinfo:build-info-extractor-gradle:4.29.0'
+    implementation 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.7.1'
+
+    testImplementation platform('org.junit:junit-bom:5.8.1')
+    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.21.0'
+    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'
+}
+
+
+test {
+    onlyIf { !project.hasProperty("buildSrc.skipTests") }
+    useJUnitPlatform()
+}

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/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,73 @@
+/*
+ * 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.springdependencymangement");
+        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,53 @@
+/*
+ * 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.publish.maven.plugins.MavenPublishPlugin
+
+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
+					}
+				}
+			}
+		}
+		project.plugins.withType(MavenPublishPlugin) {
+			project.artifactory {
+				publish {
+					defaults {
+						publications('mavenJava')
+					}
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2016-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.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.29')
+				project.dependencies.add('checkstyle', 'io.spring.nohttp:nohttp-checkstyle:0.0.3.RELEASE')
+
+				project.checkstyle {
+					configDirectory = checkstyleDir
+					toolVersion = '8.21'
+				}
+			}
+		}
+	}
+
+}

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

@@ -0,0 +1,61 @@
+package io.spring.gradle.convention
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.component.ModuleComponentSelector
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Map;
+import java.util.Properties;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.tasks.TaskAction;
+
+import io.spring.gradle.dependencymanagement.dsl.DependencyManagementExtension;
+
+public class DependencyManagementExportTask extends DefaultTask {
+    @Internal
+    def projects;
+
+    @Input
+    String getProjectNames() {
+        return projects*.name
+    }
+
+    @TaskAction
+    public void dependencyManagementExport() throws IOException {
+        def projects = this.projects ?: project.subprojects + project
+        def configurations = projects*.configurations*.findAll { ['testRuntime','integrationTestRuntime','grettyRunnerTomcat8','ajtools'].contains(it.name) }
+        def dependencyResults = configurations*.incoming*.resolutionResult*.allDependencies.flatten()
+        def moduleVersionVersions = dependencyResults.findAll { r -> r.requested instanceof ModuleComponentSelector }.collect { r-> r.selected.moduleVersion }
+
+        def projectDependencies = projects.collect { p-> "${p.group}:${p.name}:${p.version}".toString() } as Set
+        def dependencies = moduleVersionVersions.collect { d ->
+            "${d.group}:${d.name}:${d.version}".toString()
+        }.sort() as Set
+
+        println ''
+        println ''
+        println 'dependencyManagement {'
+        println '\tdependencies {'
+        dependencies.findAll { d-> !projectDependencies.contains(d)}.each {
+            println "\t\tdependency '$it'"
+        }
+        println '\t}'
+        println '}'
+        println ''
+        println ''
+        println 'TIP Use this to find duplicates:\n$ sort gradle/dependency-management.gradle| uniq -c | grep -v \'^\\s*1\''
+        println ''
+        println ''
+    }
+
+    void setOutputFile(File file) throws IOException {
+        this.output = new FileOutputStream(file);
+    }
+}

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

@@ -0,0 +1,83 @@
+/*
+ * 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 -${classifier} 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,65 @@
+/*
+ * 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 io.spring.gradle.IncludeRepoTask
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
+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()
+		}
+	}
+
+	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']
+
+	}
+
+}

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

@@ -0,0 +1,123 @@
+/*
+ * 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
+			}
+		}
+
+		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.integrationTestCompile
+				runtimeClasspath = output + compileClasspath + project.configurations.integrationTestRuntime
+			}
+		}
+
+		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.integrationTestCompile ]
+				}
+			}
+		}
+
+		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.integrationTestCompile ]
+			}
+		}
+	}
+}

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.2'
+			}
+		}
+	}
+}

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,84 @@
+/*
+ * 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()
+			jcenter() {
+				content {
+					includeGroup "org.gretty"
+				}
+			}
+			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,71 @@
+/*
+ * 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.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(ArtifactoryPlugin)
+		pluginManager.apply("org.sonarqube")
+
+		project.repositories.mavenCentral()
+
+        project.allprojects {
+            configurations.all {
+                resolutionStrategy {
+                    cacheChangingModulesFor 0, "seconds"
+                    cacheDynamicVersionsFor 0, "seconds"
+                }
+            }
+        }
+
+		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"
+			}
+		}
+
+        project.tasks.create("dependencyManagementExport", DependencyManagementExportTask)
+
+        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,53 @@
+/*
+ * 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/SpringDependencyManagementConventionPlugin.groovy

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2016-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 io.spring.gradle.dependencymanagement.DependencyManagementPlugin
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+/**
+ * Adds and configures {@link DependencyManagementPlugin}.
+ * <p>
+ * Additionally, if 'gradle/dependency-management.gradle' file is present it will be
+ * automatically applied file for configuring the dependencies.
+ */
+class SpringDependencyManagementConventionPlugin implements Plugin<Project> {
+
+    static final String DEPENDENCY_MANAGEMENT_RESOURCE = "gradle/dependency-management.gradle"
+
+    @Override
+    void apply(Project project) {
+        project.getPluginManager().apply(ManagementConfigurationPlugin)
+        project.getPluginManager().apply(DependencyManagementPlugin)
+        project.dependencyManagement {
+            resolutionStrategy {
+                cacheChangingModulesFor 0, "seconds"
+            }
+        }
+        File rootDir = project.rootDir
+        List<File> dependencyManagementFiles = [project.rootProject.file(DEPENDENCY_MANAGEMENT_RESOURCE)]
+        for (File dir = project.projectDir; dir != rootDir; dir = dir.parentFile) {
+            dependencyManagementFiles.add(new File(dir, DEPENDENCY_MANAGEMENT_RESOURCE))
+        }
+        dependencyManagementFiles.each { f ->
+            if (f.exists()) {
+                project.apply from: f.absolutePath
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,45 @@
+/*
+ * 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.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("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/SpringSampleBootPlugin.groovy

@@ -0,0 +1,40 @@
+/*
+ * 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.Project
+import org.gradle.api.plugins.PluginManager
+
+/**
+ * @author Rob Winch
+ */
+public class SpringSampleBootPlugin extends SpringSamplePlugin {
+
+    @Override
+    public void additionalPlugins(Project project) {
+        super.additionalPlugins(project);
+
+        PluginManager pluginManager = project.getPluginManager();
+
+        pluginManager.apply("org.springframework.boot");
+
+        project.repositories {
+            maven { url 'https://repo.spring.io/snapshot' }
+            maven { url 'https://repo.spring.io/milestone' }
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+/*
+ * 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.Project
+import org.sonarqube.gradle.SonarQubePlugin;
+
+/**
+ * @author Rob Winch
+ */
+public class SpringSamplePlugin extends AbstractSpringJavaPlugin {
+
+    @Override
+    public void additionalPlugins(Project project) {
+        project.plugins.withType(SonarQubePlugin) {
+            project.sonarqube.skipProject = true
+        }
+    }
+}

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

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2016-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.Project
+import org.gradle.api.Task
+import org.gradle.api.plugins.PluginManager
+import org.gradle.api.tasks.testing.Test
+
+/**
+ * @author Rob Winch
+ */
+public class SpringSampleWarPlugin extends SpringSamplePlugin {
+
+    @Override
+    public void additionalPlugins(Project project) {
+        super.additionalPlugins(project);
+
+        PluginManager pluginManager = project.getPluginManager();
+
+        pluginManager.apply("war");
+        pluginManager.apply("org.gretty");
+
+        project.gretty {
+            servletContainer = 'tomcat85'
+            contextPath = '/'
+            fileLogEnabled = false
+        }
+
+        Task prepareAppServerForIntegrationTests = project.tasks.create('prepareAppServerForIntegrationTests') {
+            group = 'Verification'
+            description = 'Prepares the app server for integration tests'
+            doFirst {
+                project.gretty {
+                    httpPort = getRandomFreePort()
+                    httpsPort = getRandomPort()
+                }
+            }
+        }
+
+        project.tasks.matching { it.name == "appBeforeIntegrationTest" }.all { task ->
+            task.dependsOn prepareAppServerForIntegrationTests
+        }
+
+        project.tasks.withType(Test).all { task ->
+            if("integrationTest".equals(task.name)) {
+                applyForIntegrationTest(project, task)
+            }
+        }
+    }
+
+    def applyForIntegrationTest(Project project, Task integrationTest) {
+        project.gretty.integrationTestTask = integrationTest.name
+
+        integrationTest.doFirst {
+            def gretty = project.gretty
+            String host = project.gretty.host ?: 'localhost'
+            boolean isHttps = gretty.httpsEnabled
+            Integer httpPort = integrationTest.systemProperties['gretty.httpPort']
+            Integer httpsPort = integrationTest.systemProperties['gretty.httpsPort']
+            int port = isHttps ? httpsPort : httpPort
+            String contextPath = project.gretty.contextPath
+            String httpBaseUrl = "http://${host}:${httpPort}${contextPath}"
+            String httpsBaseUrl = "https://${host}:${httpsPort}${contextPath}"
+            String baseUrl = isHttps ? httpsBaseUrl : httpBaseUrl
+            integrationTest.systemProperty 'app.port', port
+            integrationTest.systemProperty 'app.httpPort', httpPort
+            integrationTest.systemProperty 'app.httpsPort', httpsPort
+            integrationTest.systemProperty 'app.baseURI', baseUrl
+            integrationTest.systemProperty 'app.httpBaseURI', httpBaseUrl
+            integrationTest.systemProperty 'app.httpsBaseURI', httpsBaseUrl
+
+            integrationTest.systemProperty 'geb.build.baseUrl', baseUrl
+            integrationTest.systemProperty 'geb.build.reportsDir', 'build/geb-reports'
+        }
+    }
+
+    def getRandomPort() {
+        ServerSocket ss = new ServerSocket(0)
+        int port = ss.localPort
+        ss.close()
+        return port
+    }
+}

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,55 @@
+/*
+ * 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.plugins.JavaPlugin
+import org.gradle.jvm.tasks.Jar
+
+/**
+ * Adds the ability to depends on the test jar within other projects using:
+ *
+ * <code>
+ * testImplementation 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/org/springframework/gradle/CopyPropertiesPlugin.java

@@ -0,0 +1,38 @@
+/*
+ * 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;
+
+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/github/milestones/GitHubMilestoneApi.java

@@ -0,0 +1,110 @@
+/*
+ * 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.milestones;
+
+import com.google.common.reflect.TypeToken;
+import com.google.gson.Gson;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+import java.io.IOException;
+import java.util.List;
+
+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);
+		}
+	}
+
+//	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,75 @@
+/*
+ * 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.milestones;
+
+import org.gradle.api.Action;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.TaskAction;
+
+public class GitHubMilestoneHasNoOpenIssuesTask extends DefaultTask {
+	@Input
+	private RepositoryRef repository = new RepositoryRef();
+
+	@Input
+	private String milestoneTitle;
+
+	@Input @Optional
+	private String gitHubAccessToken;
+
+	private GitHubMilestoneApi milestones = new GitHubMilestoneApi();
+
+	@TaskAction
+	public void checkHasNoOpenIssues() {
+		long milestoneNumber = this.milestones.findMilestoneNumberByTitle(this.repository, this.milestoneTitle);
+		boolean isOpenIssues = this.milestones.isOpenIssuesForMilestoneNumber(this.repository, milestoneNumber);
+		if (isOpenIssues) {
+			throw new IllegalStateException("The repository " + this.repository + " has open issues for milestone with the title " + this.milestoneTitle + " and number " + milestoneNumber);
+		}
+		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/GitHubMilestonePlugin.java

@@ -0,0 +1,38 @@
+/*
+ * 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.milestones;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+public class GitHubMilestonePlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		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.setMilestoneTitle((String) project.findProperty("nextVersion"));
+				if (project.hasProperty("githubAccessToken")) {
+					githubCheckMilestoneHasNoOpenIssues.setGitHubAccessToken((String) project.findProperty("gitHubAccessToken"));
+				}
+			}
+		});
+	}
+}

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

@@ -0,0 +1,31 @@
+package org.springframework.gradle.github.milestones;
+
+public class Milestone {
+	private String title;
+
+	private long number;
+
+	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;
+	}
+
+	@Override
+	public String toString() {
+		return "Milestone{" +
+				"title='" + title + '\'' +
+				", number=" + number +
+				'}';
+	}
+}

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

@@ -0,0 +1,65 @@
+package org.springframework.gradle.github.milestones;
+public class RepositoryRef {
+	private String owner;
+
+	private String name;
+
+	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/maven/MavenPublishingConventionsPlugin.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2016-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.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-session");
+		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-session.git");
+		scm.getDeveloperConnection().set("scm:git:ssh://git@github.com/spring-projects/spring-session.git");
+		scm.getUrl().set("https://github.com/spring-projects/spring-session");
+	}
+
+	private void customizeIssueManagement(MavenPomIssueManagement issueManagement) {
+		issueManagement.getSystem().set("GitHub");
+		issueManagement.getUrl().set("https://github.com/spring-projects/spring-session/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/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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

buildSrc/src/test/java/io/spring/gradle/TestKit.java

@@ -0,0 +1,59 @@
+/*
+ * 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;
+
+import org.apache.commons.io.FileUtils;
+import org.gradle.testkit.runner.GradleRunner;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Paths;
+import java.util.Enumeration;
+
+public class TestKit {
+	final File buildDir;
+
+	public TestKit(File buildDir) {
+		this.buildDir = buildDir;
+	}
+
+	public File getRootDir() {
+		return buildDir;
+	}
+
+	public GradleRunner withProjectDir(File projectDir) throws IOException {
+		FileUtils.copyDirectory(projectDir, buildDir);
+		return GradleRunner.create()
+			.withProjectDir(buildDir)
+			.withPluginClasspath();
+	}
+
+	public GradleRunner withProjectResource(String projectResourceName) throws IOException, URISyntaxException {
+		ClassLoader classLoader = getClass().getClassLoader();
+		Enumeration<URL> resources = classLoader.getResources(projectResourceName);
+		if(!resources.hasMoreElements()) {
+			throw new IOException("Cannot find resource " + projectResourceName + " with " + classLoader);
+		}
+		URL resourceUrl = resources.nextElement();
+		File projectDir = Paths.get(resourceUrl.toURI()).toFile();
+		return withProjectDir(projectDir);
+	}
+}

buildSrc/src/test/java/io/spring/gradle/convention/IncludeCheckRemotePluginTest.java

@@ -0,0 +1,111 @@
+/*
+ * 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 io.spring.gradle.IncludeRepoTask;
+import org.apache.commons.io.FileUtils;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.GradleBuild;
+import org.gradle.testfixtures.ProjectBuilder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class IncludeCheckRemotePluginTest {
+
+	Project rootProject;
+
+	@AfterEach
+	public void cleanup() throws Exception {
+		if (rootProject != null) {
+			FileUtils.deleteDirectory(rootProject.getProjectDir());
+		}
+	}
+
+	@Test
+	void applyWhenExtensionPropertiesNoTasksThenCreateCheckRemoteTaskWithDefaultTask() {
+		this.rootProject = ProjectBuilder.builder().build();
+		this.rootProject.getPluginManager().apply(IncludeCheckRemotePlugin.class);
+		this.rootProject.getExtensions().configure(IncludeCheckRemotePlugin.IncludeCheckRemoteExtension.class,
+				(includeCheckRemoteExtension) -> {
+					includeCheckRemoteExtension.setProperty("repository", "my-project/my-repository");
+					includeCheckRemoteExtension.setProperty("ref", "main");
+				});
+
+		GradleBuild checkRemote = (GradleBuild) this.rootProject.getTasks().named("checkRemote").get();
+		assertThat(checkRemote.getTasks()).containsExactly("check");
+	}
+
+	@Test
+	void applyWhenExtensionPropertiesTasksThenCreateCheckRemoteWithProvidedTasks() {
+		this.rootProject = ProjectBuilder.builder().build();
+		this.rootProject.getPluginManager().apply(IncludeCheckRemotePlugin.class);
+		this.rootProject.getExtensions().configure(IncludeCheckRemotePlugin.IncludeCheckRemoteExtension.class,
+				(includeCheckRemoteExtension) -> {
+					includeCheckRemoteExtension.setProperty("repository", "my-project/my-repository");
+					includeCheckRemoteExtension.setProperty("ref", "main");
+					includeCheckRemoteExtension.setProperty("tasks", Arrays.asList("clean", "build", "test"));
+				});
+
+		GradleBuild checkRemote = (GradleBuild) this.rootProject.getTasks().named("checkRemote").get();
+		assertThat(checkRemote.getTasks()).containsExactly("clean", "build", "test");
+	}
+
+	@Test
+	void applyWhenExtensionPropertiesThenRegisterIncludeRepoTaskWithExtensionProperties() {
+		this.rootProject = ProjectBuilder.builder().build();
+		this.rootProject.getPluginManager().apply(IncludeCheckRemotePlugin.class);
+		this.rootProject.getExtensions().configure(IncludeCheckRemotePlugin.IncludeCheckRemoteExtension.class,
+				(includeCheckRemoteExtension) -> {
+					includeCheckRemoteExtension.setProperty("repository", "my-project/my-repository");
+					includeCheckRemoteExtension.setProperty("ref", "main");
+				});
+
+		IncludeRepoTask includeRepo = (IncludeRepoTask) this.rootProject.getTasks().named("includeRepo").get();
+		assertThat(includeRepo).isNotNull();
+		assertThat(includeRepo.getRepository().get()).isEqualTo("my-project/my-repository");
+		assertThat(includeRepo.getRef().get()).isEqualTo("main");
+	}
+
+	@Test
+	void applyWhenRegisterTasksThenCheckRemoteDirSameAsIncludeRepoOutputDir() {
+		this.rootProject = ProjectBuilder.builder().build();
+		this.rootProject.getPluginManager().apply(IncludeCheckRemotePlugin.class);
+		this.rootProject.getExtensions().configure(IncludeCheckRemotePlugin.IncludeCheckRemoteExtension.class,
+				(includeCheckRemoteExtension) -> {
+					includeCheckRemoteExtension.setProperty("repository", "my-project/my-repository");
+					includeCheckRemoteExtension.setProperty("ref", "main");
+				});
+		IncludeRepoTask includeRepo = (IncludeRepoTask) this.rootProject.getTasks().named("includeRepo").get();
+		GradleBuild checkRemote = (GradleBuild) this.rootProject.getTasks().named("checkRemote").get();
+		assertThat(checkRemote.getDir()).isEqualTo(includeRepo.getOutputDirectory());
+	}
+
+	@Test
+	void applyWhenNoExtensionPropertiesThenRegisterTasks() {
+		this.rootProject = ProjectBuilder.builder().build();
+		this.rootProject.getPluginManager().apply(IncludeCheckRemotePlugin.class);
+		IncludeRepoTask includeRepo = (IncludeRepoTask) this.rootProject.getTasks().named("includeRepo").get();
+		GradleBuild checkRemote = (GradleBuild) this.rootProject.getTasks().named("checkRemote").get();
+		assertThat(includeRepo).isNotNull();
+		assertThat(checkRemote).isNotNull();
+	}
+
+}

buildSrc/src/test/java/io/spring/gradle/convention/IntegrationPluginTest.java

@@ -0,0 +1,52 @@
+/*
+ * 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.apache.commons.io.FileUtils;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.testfixtures.ProjectBuilder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Rob Winch
+ */
+public class IntegrationPluginTest {
+	Project rootProject;
+
+	@AfterEach
+	public void cleanup() throws Exception {
+		if (rootProject != null) {
+			FileUtils.deleteDirectory(rootProject.getProjectDir());
+		}
+	}
+
+	@Test
+	public void applyWhenNoSourceThenIntegrationTestTaskNull() {
+		rootProject = ProjectBuilder.builder().build();
+		rootProject.getPlugins().apply(JavaPlugin.class);
+		rootProject.getPlugins().apply(IntegrationTestPlugin.class);
+
+		assertThat(rootProject.getTasks().findByPath("integrationTest")).isNull();
+	}
+
+}

buildSrc/src/test/java/io/spring/gradle/convention/IntegrationTestPluginITest.java

@@ -0,0 +1,52 @@
+package io.spring.gradle.convention;
+
+import io.spring.gradle.TestKit;
+import org.gradle.testkit.runner.BuildResult;
+import org.gradle.testkit.runner.TaskOutcome;
+import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.nio.file.Path;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class IntegrationTestPluginITest {
+	private io.spring.gradle.TestKit testKit;
+
+	@BeforeEach
+	void setup(@TempDir Path tempDir) {
+		this.testKit = new TestKit(tempDir.toFile());
+	}
+
+    @Test
+	public void checkWithJavaPlugin() throws Exception {
+        BuildResult result = this.testKit.withProjectResource("samples/integrationtest/withjava/")
+				.withArguments("check")
+				.build();
+		assertThat(result.task(":check").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+		assertThat(new File(testKit.getRootDir(), "build/test-results/integrationTest/")).exists();
+		assertThat(new File(testKit.getRootDir(), "build/reports/tests/integrationTest/")).exists();
+	}
+
+	@Test
+    public void checkWithPropdeps() throws Exception {
+        BuildResult result = this.testKit.withProjectResource("samples/integrationtest/withpropdeps/")
+				.withArguments("check")
+				.build();
+		assertThat(result.task(":check").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+		assertThat(new File(testKit.getRootDir(), "build/test-results/integrationTest/")).exists();
+		assertThat(new File(testKit.getRootDir(), "build/reports/tests/integrationTest/")).exists();
+	}
+
+	@Test
+    public void checkWithGroovy() throws Exception {
+		BuildResult result = this.testKit.withProjectResource("samples/integrationtest/withgroovy/")
+				.withArguments("check")
+				.build();
+		assertThat(result.task(":check").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+		assertThat(new File(testKit.getRootDir(), "build/test-results/integrationTest/")).exists();
+		assertThat(new File(testKit.getRootDir(), "build/reports/tests/integrationTest/")).exists();
+	}
+}

buildSrc/src/test/java/io/spring/gradle/convention/JacocoPluginITest.java

@@ -0,0 +1,31 @@
+package io.spring.gradle.convention;
+
+import org.gradle.testkit.runner.BuildResult;
+import org.gradle.testkit.runner.TaskOutcome;
+import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.nio.file.Path;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JacocoPluginITest{
+	private io.spring.gradle.TestKit testKit;
+
+	@BeforeEach
+	void setup(@TempDir Path tempDir) {
+		this.testKit = new io.spring.gradle.TestKit(tempDir.toFile());
+	}
+
+    @Test
+	public void checkWithJavaPlugin() throws Exception {
+        BuildResult result = this.testKit.withProjectResource("samples/jacoco/java/")
+				.withArguments("check")
+				.build();
+		assertThat(result.task(":check").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+		assertThat(new File(testKit.getRootDir(), "build/jacoco")).exists();
+		assertThat(new File(testKit.getRootDir(), "build/reports/jacoco/test/html/")).exists();
+	}
+}

buildSrc/src/test/java/io/spring/gradle/convention/JavadocApiPluginITest.java

@@ -0,0 +1,38 @@
+package io.spring.gradle.convention;
+
+import io.spring.gradle.TestKit;
+import org.apache.commons.io.FileUtils;
+import org.gradle.testkit.runner.BuildResult;
+import org.gradle.testkit.runner.TaskOutcome;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.nio.file.Path;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JavadocApiPluginITest {
+	private TestKit testKit;
+
+	@BeforeEach
+	void setup(@TempDir Path tempDir) {
+		this.testKit = new TestKit(tempDir.toFile());
+	}
+
+	@Test
+    public void multiModuleApi() throws Exception {
+        BuildResult result = this.testKit.withProjectResource("samples/javadocapi/multimodule/")
+				.withArguments("api")
+				.build();
+		assertThat(result.task(":api").getOutcome()).isEqualTo(TaskOutcome.SUCCESS);
+        File allClasses = new File(testKit.getRootDir(), "build/api/allclasses-noframe.html");
+		File index = new File(testKit.getRootDir(), "build/api/allclasses.html");
+		File listing = allClasses.exists() ? allClasses : index;
+		String listingText = FileUtils.readFileToString(listing);
+		assertThat(listingText).contains("sample/Api.html");
+        assertThat(listingText).contains("sample/Impl.html");
+		assertThat(listingText).doesNotContain("sample/Sample.html");
+	}
+}

buildSrc/src/test/java/io/spring/gradle/convention/JavadocApiPluginTest.java

@@ -0,0 +1,56 @@
+/*
+ * 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 org.apache.commons.io.FileUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.javadoc.Javadoc;
+import org.gradle.testfixtures.ProjectBuilder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author Rob Winch
+ */
+public class JavadocApiPluginTest {
+	Project rootProject;
+
+	@AfterEach
+	public void cleanup() throws Exception {
+		if (rootProject != null) {
+			FileUtils.deleteDirectory(rootProject.getProjectDir());
+		}
+	}
+
+	@Test
+	public void applyWhenNotOverrideThenPropertiesDefaulted() {
+		rootProject = ProjectBuilder.builder().build();
+		rootProject.getPlugins().apply(JavadocApiPlugin.class);
+
+		Javadoc apiTask = (Javadoc) rootProject.getTasks().getByPath("api");
+
+		assertThat(apiTask).isNotNull();
+		assertThat(apiTask.getGroup()).isEqualTo("Documentation");
+		assertThat(apiTask.getDescription()).isEqualTo("Generates aggregated Javadoc API documentation.");
+		assertThat(apiTask.getMaxMemory()).isEqualTo("1024m");
+		assertThat(apiTask.getDestinationDir()).isEqualTo(new File(rootProject.getBuildDir(), "api"));
+	}
+
+}