Don't be scared off by this document! If you already understand the stuff in the glossary section and are only working on a HotSpot release, then skip to Steps for every version later on.
- A private group of trusted people who take reports of vulnerabilities in the openjdk codebase and work to resolve them and get them into releases in a timely manner
- Maintainers work on quarterly update fixes for the next update, in the head stream of the updates repository e.g. https://hg.openjdk.java.net/jdk-updates/jdk11u
- Fixes for the subsequent update are developed in the
dev
stream e.g. https://hg.openjdk.java.net/jdk-updates/jdk11u-dev/ - Regular builds are tagged every week or so, e.g.
jdk-11.0.5+6
- Eventually after final testing it comes to general availability (GA) day for the update, at this point any fixes from the Vulnerability Group are merged with the final GA build, and tagged, e.g.
jdk-11.0.5+10
,jdk-11.0.5-ga
- The most recent JDK release updates are managed by Oracle, and there will only be two of them, e.g. for
jdk-13
Oracle producedjdk-13.0.1
andjdk-13.0.2
. - Oracle work on the quarterly updates internally and these update source branches and Vulnerability Group fixes are not public until GA date.
- On GA day, Oracle merges the internal branch and Vulnerability Group fixes to produce the final GA build, and this is tagged, e.g.
jdk-13.0.1+9
,jdk-13.0.1-ga
- If the release is a short term support release there are no more releases after the two Oracle-led updates, but if it is a long term support (LTS) release the OpenJDK community picks up subsequent release maintenance, and all work continues in public as described above.
- Wait for Red Hat/Oracle to push the GA code to GitHub and announce availability:
- jdk8u : https://github.com/openjdk/jdk8u
- jdk11u and later:
- jdkXX: https://github.com/openjdk/jdkXX/
During the week before release, the Release Champion makes changes in preparation for the release:
- Update releaseVersions with correct incoming release versions.
- Update https://github.com/adoptium/mirror-scripts/blob/master/releasePlan.cfg with expected tag, detail see https://github.com/zdtsw/mirror-scripts/tree/issue/3167#skara-repos-and-processes
Post the below message to the #build & #release channels in Slack:
In Preparation for next weeks release, I'm proposing to branch the following repositories, in order that this branch becomes the baseline for the release. Shout now if you need to get any PRs merged for the release, as today is the last day, the following repositories will be branched: ( temurin-build, ci-jenkins-pipelines, jenkins-helper).
Create release branch in the format vYYYY.MM.NN
on each of the following repositories:
- temurin-build https://github.com/adoptium/temurin-build
- ci-jenkins-pipelines https://github.com/adoptium/ci-jenkins-pipelines
- jenkins-helper https://github.com/adoptium/jenkins-helper
These branches should be named according to the following format (vYYYY.MM.NN) ,e.g v2023.03.01 , whereby the final element is an incremental counter appended to the year and month of the release.
If anything needs to be merged into the new branch, it should typically be merged into master, then a git cherry-pick
operation should be done to create a new PR against the release branch. This can typically be merged without further approval.
Paste the below message into the #release channel in Slack:
With under a week to go until releases, we are entering a lockdown period for the master
branches in the following repositories: github-release-scripts, containers, installer, and mirror-scripts. The temurin-build, ci-jenkins-pipelines and jenkins-helper master branches are still open for work, however the release branch will be under code-freeze management.
If you need to submit a pr for any of these repos during this period, you should:
- Add a comment saying “Approval to merge during the lockdown cycle please” and post in the appropriate slack channel for awareness. This can be done before the PR is finalised.
- Add a note into this channel saying you are requesting the approval with a link to the comment in the first bullet point.
- The comment should have approval from at least one build committer and one PMC member to indicate that they agree it is critical that it goes in.
- The PR can be merged after 2 hours of the post going into the build channel (to give people time to object). This delay may be skipped in cases where the delay will result in something breaking within that time.
Only include "critical" fixes (i.e. those which will otherwise cause a build break or other problem which will prevent shipping the release builds). This stops last minute changes going in, which may destabilise things. "installer" repo might have exception due to the fact it requires new version of build. If a change has to go in during this "lockdown" period it should be done by posting a comment saying "Requesting approval to merge during the lockdown period. Please thumbs up the comment to approve" in Slack release channel. If two committers into the repository express approval then the change can be merged during the lockdown period.
In order to enable the code freeze GitHub you need to change the line if: github.repository_owner == 'adoptium' && false
to be if: github.repository_owner == 'adoptium' && true
in the code-freeze.yml GitHub workflow. Please contact the PMC if you need help merging this change.
Affected repositories:
master branch:
- github-release-scripts https://github.com/adoptium/github-release-scripts
- containers https://github.com/adoptium/containers
- installer https://github.com/adoptium/installer
- mirror-script https://github.com/adoptium/mirror-scripts
release branch:
- temurin-build https://github.com/adoptium/temurin-build
- ci-jenkins-pipelines https://github.com/adoptium/ci-jenkins-pipelines
- jenkins-helper https://github.com/adoptium/jenkins-helper
- run release-pipeline-generator with correct value:
releaseTag
is the branch onci-jenkins-pipeline
andtemurin-build
git repo.helperTag
is the branch onjenkins-helper
repo.aqaTag
is the branch onaqa-tests
repo, in form ofvX.Y.Z-release
and usually the latest stable release
- ensure release-openjdkXX-pipeline in https://ci.adoptium.net/job/build-scripts are properly generated for the first time or updated:
- jdk8 aarch32Linux shares the same pipeline
release-openjdk8-pipeline
with other jdk8 targets, therefore, only one release pipeline for jdk8 targetConfigurations
should only include what we officially release for temurin.buildReference
andciReference
should have the value ofreleaseTag
used when we generate pipeline.helperReference
should have the same value ofhelperTag
used when we generate pipeline.
- jdk8 aarch32Linux shares the same pipeline
- ensure downstream build jobs in https://ci.adoptium.net/job/build-scripts/job/jobs/job/release/job/jobs/jdkXXu/ are created or updated
BUILD_CONFIGURATION.USE_ADOPT_SHELL_SCRIPTS
is set totrue
DEFAULTS_JSON.repository.build_branch
,ADOPT_DEFAULTS_JSON.repository.build_branch
,DEFAULTS_JSON.repository.pipeline_branch
andADOPT_DEFAULTS_JSON.repository.pipeline_branch
should get correct release branch name asreleaseTag
DEFAULTS_JSON.repository.helper_ref
andADOPT_DEFAULTS_JSON.repository.helpe_ref
should get correct release branch name ashelperTag
FLOW CHART OF THE PIPELINE GENERATOR PROCESS
flowchart TD
1["ReleaseChampion"] -- manual run --> 2["release-build-pipeline-generator"]
2 --generate--> 3.1["release-openjdk8-pipeline"]
2 --call--> 3.2["release_pipeline_jobs_generator_jdk8u"]
2 --generate--> 3.3["release-openjdk11-pipeline"]
2 --call--> 3.4["release_pipeline_jobs_generator_jdk11u"]
2 --generate--> 3.5["release-openjdk17-pipeline"]
2 --call--> 3.6["release_pipeline_jobs_generator_jdk17u"]
2 --generate--> 3.7["release-openjdkXX-pipeline"]
2 --call--> 3.8["release_pipeline_jobs_generator_jdkXXu"]
3.2-- create --> 3.2.1["jdk8u-release-mac-x64-temurin"]
3.2-- create --> 3.2.2["jdk8u-release-linux-x64-temurin"]
3.2-- create --> 3.2.3["jdk8u-release-<os>-<arch>-temurin"]
3.4-- create --> 3.4.1["jdk11u-release-mac-x64-temurin"]
3.4-- create --> 3.4.2["jdk11u-release-linux-x64-temurin"]
3.4-- create --> 3.4.3["jdk11u-release-<os>-<arch>-temurin"]
3.6-- create --> 3.6.1["jdk17u-release-mac-x64-temurin"]
3.6-- create --> 3.6.2["jdk17u-release-linux-x64-temurin"]
3.6-- create --> 3.6.3["jdk17u-release-<os>-<arch>-temurin"]
3.8-- create --> 3.8.1["jdkXXu-release-mac-x64-temurin"]
3.8-- create --> 3.8.2["jdkXXu-release-linux-x64-temurin"]
3.8-- create --> 3.8.3["jdkXXu-release-<os>-<arch>-temurin"]
Disable nightly testing so the release builds aren't delayed by any nightly test runs (set enableTests : false
in defaults.json). Ensure the build pipeline generator job runs successfully (https://ci.adoptium.net/job/build-scripts/job/utils/job/build-pipeline-generator/), and the flag is disabled by bringing up the Build pipeline job and check the enableTests
checkbox is unticked.
Add a banner to the website to indicate that the releases are coming in the near future (Example Changes).
In order to reduce time to GA, we have automated triggers to ensure that the GA build pipelines are triggered as soon as the GA tags come out so it does not rely on one of the Adoptium team members watching it and kicking them off manually. These examples use JDK17 - adjust for the version you're interested in.
Note that while the generated pipelines will include a configuration for x32Windows
we should manually disable that before the triggers run to avoid those taking CPU time away from the x64 machines. The pipelines should be re-triggered with ONLY the x32Windows
configuration approximately 48 hours after the initial triggers once most of the Windows 64-bit ones are complete for all versions.
- Jenkins "release trigger" job (e.g https://ci.adoptium.net/job/build-scripts/job/utils/job/releaseTrigger_jdk17u/) runs every hour in the release week to check if new GA tag has been detected in the adoptium's source code repo - the script run from the checks for the new release every 10 minutes five times (e.g https://github.com/adoptium/jdk17u) This excludes https://github.com/adoptium/aarch32-jdk8u
- If it finds new GA tag matches expected tag set in mirror-script repo, job triggers release-openjdk19-pipeline (e.g https://ci.adoptium.net/job/build-scripts/job/release-openjdk19-pipeline/) with parameters:
scmReference
. - If it couldn't find the correct "_adopt" tag but GA tag has been applied in the upstream Skara source code repo. Several things can check:
- If the appropriate [mirror job](e.g https://ci.adoptium.net/view/git-mirrors/job/git-mirrors/job/adoptium/job/git-skara-jdk19u/) has successfully received the tag. Could be a merge conflict blocking creation of "_adopt" tag.
- If the expectedTag set in "mirror-script" repo is wrong/typo.
- Check "release trigger" job, spot anything abnormal from console log.
"release-openjdkXX-pipeline" can be manually run by Release Champion: set scmReference
with correct "_adopt" tag.
- For jdk8 arm32Linux, the Release Champion needs to manually trigger https://ci.adoptium.net/job/build-scripts/job/release-openjdk8-pipeline/
- different
scmReference
tag from https://github.com/adoptium/aarch32-jdk8u than in https://github.com/adoptium/jdk8u (with the_adopt
suffix) - customized
targetConfigurations
value: should only contain the target architecture ofarm32Linux
- customized
overridePublishName
value - use the tag consistent with the other architectures (e.g.jdk8uXXX-bYY
)
FLOW CHART OF THE RELEASE TRIGGER PROCESS
flowchart TD
start["Every hour"] --trigger--> step0["releaseTrigger job"] --> step1["Check GA tag available\nCheck _adopt tag available"] ----> |yes| step2["Trigger release-openjdkXX-pipeline\nwith scmReference"] --> step3["Trigger all jdkXXu-release-OS-ARCH-temurin job\nExcept jdk8u-release-linux-arm-temurin when XX is 8"] --> step4["Trigger remote Temurin compliance CI jck test jobs: jck.sanity,jck.extended,jck.special"]
step1 ---->|No| step1.1["sleep 10 minutes"] -->step1
jdk8armStep1["ReleaseChampion check once GA tag on jdk8 aarch32Linux is ready"] -->jdk8armStep2["Get _adopt tag on jdk8 aarch32Linux"] -->jdk8armStep3["Manual run release-openjdk8u-pipeline with\n1: scmReference\n2: targetConfiguration\n3: overridePublishName"]
It is recommended that we perform an auto trigger test on a chosen version (suggest jdk8 and one other) to validate the trigger and build processes and the release pipeline. jdk-17 example:
- Update releasePlan.cfg with the correct version numbers for the new release.
- Choose the second latest openjdk tag without the
_adopt
suffix (unless it is the same as the latest in which case keep going backwards..) in the adoptium/jdkNNu repository that you are using for the dry run. - Ensure that the branch of aqa_tests has been created for this release.
- Update testenv/testenv.properties in the branch of aqa-tests to point to the tag as the JDKnn_BRANCH e.g.
jdk-17.0.x+y
(i.e. notdev
) - Get an Adoptium administrator to create the
-dryrun-ga
tag to build in the adoptium mirror, as in the following example:
IMPORTANT: trial tag MUST be something that is sorted before -ga
. Recommended format: "-dryrun-ga"
git clone [email protected]:adoptium/jdk17u.git
cd jdk17u
git tag -a "jdk-17.0.6-dryrun-ga" jdk-17.0.6+8^{} -m"YYYY.MM release dry run test"
git push --tags origin master
- Wait for the release trigger job to detect the tag (wait up to 10mins), e.g. releaseTrigger_jdk17u (Note that the schedule for that job is only run on the release months, so may not work if you are keen and try to do this in the month before)
- The trial release pipeline job should now be running, eg: https://ci.adoptium.net/job/build-scripts/job/release-openjdk17-pipeline/
- Once you have verified that everything looks good, testenv.properties should be adjusted to have the expected GA tag before the final release appears.
If the tag in step 5 MUST NOT contain the +nn from the underlying tag. If you accidentally create a +nn-dryrun-ga then you will get this error from openjdk_pipeline.groovy:
[INFO] Resolved jdk-17.0.11-dryrun-ga to upstream build tag jdk-17.0.11+6jdk-17.0.11+6-dryrun-ga
[ERROR] scmReference does not match with any JDK branch in testenv.properties in aqa-tests release branch. Please update aqa-tests v1.0.1-release release branch. Set the current build result to FAILURE!
Deleting the tag will not fix the problem as it will have been cached on the jenkins worker node used for the trigger jobs - see adoptium/temurin#28 (comment) for the details, but you'll need to manually adjust build-scripts/utils/./releaseTrigger_jdk*/workspace/tracking
Manual execution of the build pipelines (without using trigger jobs - now mostly obsolete other than jdk8u/arm32)
Here are the old manual steps:
- Ensure that the appropriate mirror job has completed and that the corresponding repository at https://github.com/adoptium/jdkXX has successfully received the tag for the level you are about to build. If there are any conflicts they can be resolved on the machine where it failed if you have access to the private
adoptium_temurin_bot_ssh_key.gpg
key, or ask someone( e.g @gdams or @andrew-m-leonard) with push access to the repositories to manually run the mirror job and resolve the conflicts. - Run OpenJDK pipeline build and test release:
- Job: https://ci.adoptium.net/job/build-scripts/job/openjdk8-pipeline/build (Switch
openjdk8
for your version number) targetConfigurations
:- only keep temurin variants
- make sure windows aarch64 is not presented (as this is written, it is not officially supported yet)
releaseType: Release
adoptBuildNumber
: Leave blank unless you are doing a point release in which case it should be a number starting at1
for the first point release.additionalConfigureArgs
:- For JDK8, no need change default value. It automatically adds
--with-milestone=fcs
inbuild.sh
. - For JDK11+ use
--without-version-pre --without-version-opt
(for EA releases use:--with-version-pre=ea --without-version-opt
)
- For JDK8, no need change default value. It automatically adds
scmReference
: One of the following:- For jdk8 aarch32Linux, the tag usually takes the form
jdk8u322-b04-aarch32-xxxxxxxx
- For the rest, it's the same tag suffixed with
_adopt
e.g.jdk-17.0.2+9_adopt
- For jdk8 aarch32Linux, the tag usually takes the form
buildReference
: tag or the ongoing release on temurin-build repociReference
: tag or the ongoing release on ci-jenkins-pipeline repohelperReference
: tag for the ongoing release on jenkins-helper repooverridePublishName
: only for jdk8 aarch32Linux, to set to the actual OpenJDK tag (jdk8u322-b04
)aqaReference
should be set to the appropriate branch of theaqa-tests
repository which is appropriate for this release. Generally of the formvX.Y.Z-release
enableTests
: tick- Click "Build" button !!!
Once the openjdk pipeline has completed:
- Triage TRSS result:
- Follow triage the results. Go to TRSS which will guide you through creating an aqa test triage issue for the release
- Find the section of each jdk build, e.g
openjdk8-pipeline in server https://ci.adoptium.net/job/build-scripts
for JDK8 - Click "Grid" link on the correct Build row
- Check if not all are "Green", create new "release triage" issue in
aqa-tests
repository, set description to "Release Summary Report" content and follow the Jenkins link to triage error and failure. - Raise issues either at:
- temurin-build (for Adoptium build script)
- aqa-tests ( for test issues)
- ci-jenkins-pipelines (for jenkins pipelines specific issues)
- Discuss failing tests with Shelley Lambert or post on testing-aqavit Slack channel
- Once all AQA tests on all platforms and all JDK versions have been signed off, then nightly tests can be re-enabled. See the notes on "Disable nightly testing".
- Publish build results:
-
If "good to publish", get permission to publish the release from the Adoptium PMC members, discussion is via the Adoptium #release Slack channel.
-
Once permission has been obtained, run the openjdk_release_tool to publish the releases to GitHub (restricted access - if you can't see this link, you don't have access). It is strongly recommended that you run first with the
DRY_RUN
checkbox enabled and check the output to verify that the correct list of files you expected are picked up.--
TAG
: (GitHub binaries published name) e.g.jdk-11.0.5+9
. If doing a point release, add that into the name e.g. for a.3
release use something like this:jdk8u232-b09.3
--VERSION
: (select version e.g.jdk11
) --UPSTREAM_JOB_NAME
: e.g "build-scripts/release-openjdkXX-pipeline" for new way and "build-scripts/openjdkXX-pipeline" for old way --UPSTREAM_JOB_NUMBER
: the build number of above upstream job, e.g. 86 --RELEASE
: "ticked" -- If you need to restrict the platforms or only ship jdks or jres, either useARTIFACTS_TO_COPY
e.g.**/*jdk*mac*
or add an explicit exclusion inARTIFACTS_TO_SKIP
e.g.**/*mac*
. These may be required if you had to re-run some of the platforms under a different pipeline earlier in the process. If you're unsure what the possible names are, look at the artifacts of the appropriateopenjdkNN-pipeline
job. If you are shipping x64_linux ensure that you include thesources
tar.gz files with the corresponding checksum and json file. --ARTIFACTS_TO_SKIP
:**/*testimage*
-- If you need to restrict the platforms, fill inARTIFACTS_TO_COPY
and if needed add toARTIFACTS_TO_SKIP
. This may also be required if you had to re-run some of the platforms under a different pipeline earlier in the process. I personally tend to find it cleaner to release Linux in one pipeline, Windows+Mac in another, then the others together to keep the patterns simpler. Sample values forARTIFACTS_TO_COPY
are as follows (use e.g._x64_linux_
to restrict by architecture if required): ---**/*_linux_*.tar.gz,**/*_linux_*.sha256.txt,**/*_linux_*.json,**/*_linux_*.sig
(Exclude**/*alpine_linux*
if you don't really want that to be picked up too) --- Alternative that wouldn't pick up Alpine:target/linux/x64/hotspot/**.tar.gz,target/linux/x64/hotspot/target/linux/x64/hotspot/*.sha256.txt
---**/*_mac_*.tar.gz,**/*_mac_*.sha256.txt,**/*_mac_*.json,**/*_mac_*.pkg,**/*_mac_*.sig
---**/*_windows_*.zip,**/*_windows_*.sha256.txt,**/*_windows_*.json,**/*_windows_*.msi,**/*_windows_*.sig
---**/*_aix_*.tar.gz,**/*_aix_*.sha256.txt,**/*_aix_*.json,**/*_aix_*.sig
---**/*_solaris_*.tar.gz,**/*_solaris_*.sha256.txt,**/*_solaris_*.json,**/*_solaris_*.sig
-- Click "Build" button !!! -
Once the job completes successfully, check the binaries have uploaded to GitHub at somewhere like https://github.com/adoptium/temurin8-binaries/releases/tag/jdk8u302-b08
-
Within 15 minutes the binaries should be available on the website too. e.g. https://adoptium.net/?variant=openjdk11&jvmVariant=hotspot (NOTE: If it doesn't show up, check whether the API is returning the right thing (e.g. with a link such as this, and that the
.json
metadata files are uploaded correctly) -
During the waiting time, good to update:
-- https://github.com/adoptium/website-v2/blob/main/src/asciidoc-pages/support.adoc which is the source of https://adoptium.net/support (Sample change) -- (if required) the supported platforms table at https://github.com/adoptium/website-v2/edit/main/src/asciidoc-pages/supported-platforms.adoc which is the source of https://adoptium.net/supported-platforms
- Publish AQA test results:
Once all supported platform binaries have been released it's time to publish AQA test results. This can be done by two steps
- Collect AQA test results, run jenkins job TAP_Collection
- Publish the results, run the restricted access release tool job by setting UPLOAD_TESTRESULTS_ONLY, ARTIFACTS_TO_COPY=**/*.tar.gz and UPSTREAM_JOB_NAME=TAP_Collection
- Publish packages for different OS
4.1. [Mac only] Once the binaries are available on the website you need to update the Homebrew casks. There are 4 casks in total
and all but the first one is in the hombrew-cask-versions
repository. If you're doing a point release, the format of the version string is 11.0.20.1,1 so the version is always the same as "our" one but with the +
replaced with a ,
An example PR can be found here. The required SHA sums can be updated by brew bump-cask-pr temurinXX --version 11.0.XX,Y
command if you're on a macos system, or manually if not . The separate pull request is required for each version you update. If in doubt reach out to @gdams as he's a maintainer.
4.2. [Linux only] Once the binaries are available on the website you can begin updating the specfiles for the RPM/DEB/APK files. There are 4 different types of linux installer
-
All need to be updated:
- Debian you need to locate the
rules
file for each version. This file contains the URLs and Checksums for each package (example). Thechangelog
file should also be updated for the new version. - Red Hat/SuSE you need to modify the
temurin-<version>-jdk.spec
file for each version. The links/checksum links are all defined asSource<number>
variables (example). - Alpine you need to modify pkgver and checksum
- Debian you need to locate the
Once the PRs to change those files have been merged, the adoptium-packages-linux-pipeline job needs to be kicked off. It is recommended to run it without the UPLOAD checkbox to begin with as a 'dry-run' before re-running with the UPLOAD
checkbox ticked to publish to our JFrog artifactory instance.
-
[Docker Hub] The information on updating the Adoptium official dockerhub repository is at https://github.com/adoptium/containers#maintenance-of-dockerfiles at the moment you cannot do this until all Linux architectures and windows64 are published for the appropriate version
-
Once everything has been published to GitHub, use the EclipseMirror job to mirror the artifacts to our Eclipse server for backup purposes. Note that this will need to be done by a team member in the temurin-compliance project (Run once for each of the releases)
-
Publicise the Temurin release:
- Via slack on the Adoptium #release channel
- Find someone with the appropriate authority (Carmen, George, Martijn, Shelley, Stewart, Tim) to post a tweet about the new release from the Adoptium twitter account
Once all the release binaries have been published the following tasks should be completed: If the latest version just released has come to the end of its non-LTS lifecycle (2 CPU updates, eg.jdk-15.0.2)
- disable and retire that version from the Nightly and Evaluation pipeline builds: e.g https://github.com/adoptium/ci-jenkins-pipelines/pull/628/files
- update pr-test job to not include this version
For the api.adoptium.net repository:
- Update the LATEST_JAVA_VERSION_PROPERTY in Versions.kt to be n+1, where n is the highest major version you've just released.
- Ensure that LATEST_JAVA_VERSION is not set on the api.adoptium.net server, as it will override the LATEST_JAVA_VERSION_PROPERTY.
-
The refers to a "new" major (Short or Long Term) OpenJDK Release (e.g. jdk13, jdk14, ...)
-
Oracle and contributors work on releases in the "head" OpenJDK stream: https://hg.openjdk.java.net/jdk/jdk
-
3 months prior to the GA date, the
head
stream is branched into a new release stream for development rampdown e.g. https://hg.openjdk.java.net/jdk/jdk13 -
Regular builds are tagged every week or so in a format such as
jdk-13+21
-
Eventually after rampdown and final phase testing the GA build is tagged and released, e.g. the
jdk-13-ga
code level is tagged along side the actual release build tag. -
When a new release occurs, we must also update one of our job generators to match the new jdk versions and remove old STR that are no longer needed. The full details on what these are in the regeneration README.md but for a quick run down on how to update them when we want to build a new release, follow the steps below:
- Update the Job Folder - https://ci.adoptium.net/job/build-scripts/job/utils/: The jobs themselves you are looking for are called
pipeline_jobs_generator_jdkxx
(pipeline_jobs_generator_jdk
for HEAD). Firstly, ensure that the job description of each generator (and it's parameter's descriptions) are up to date. Then, follow these steps:
- If you are ADDING a JDK version:
- Ensure that JDK N-1 is available as build JDK on the builders. For example in order to build JDK 15, JDK 14 needs to be installed on the build machines. As a temporary measure, code so as to download the JDK to the builder via the API has been added. NOTE: For the transition period shortly after a new JDK has been branched, there might not yet exist a generally available release of JDK N-1.
- Ensure that JDK sources are being mirrored. Example infrastructure request
- Ensure that a repository which contains the binary releases exists. Example temurin15-binaries
- Add build scripts for the new JDK release. Example for JDK 14
- Regenerate build jobs:
- Create a New Item in the folder linked above that copies the
pipeline_jobs_generator_jdk
job. Call itpipeline_jobs_generator_jdk<new-version-number>
. - Change the
Script Path
setting of the new job topipelines/build/regeneration/jdk<new-version-number>_regeneration_pipeline.groovy
. Don't worry if this currently doesn't exist in this repository, you'll add it in step 3. - Update the
Script Path
setting of the JDK-HEAD job (pipeline_jobs_generator_jdk
) to whatever the new JDK HEAD is. I.e. if the new head is JDK16, changeScript Path
topipelines/build/regeneration/jdk16_regeneration_pipeline.groovy
- Create a New Item in the folder linked above that copies the
- If you are REMOVING a JDK version:
- Delete the job
pipeline_jobs_generator_jdk<version-you-want-to-delete>
- Delete the job
- Create the new build configurations for the release - https://github.com/adoptium/ci-jenkins-pipelines/tree/master/pipelines/jobs/configurations:
- Create a new
jdk<new-version-number>_pipeline_config.groovy
file with the desiredbuildConfigurations
for the new pipeline. 99% of the time, copy and pasting the configs from the previous version is acceptable. Ensure that the classname and instance of it is changed toConfig<new-version-number>
. Don't remove any old version configs. - Furthermore, you will also need to create another config file to state what jobs will be run with any new versions. If it doesn't currently exist, add a
jdkxx.groovy
file to configurations/. Example on how to do this. Note, some files will need to be namedjdkxxu.groovy
depending on whether the version is maintained in an update repository or not. These will be the ONLY os/archs/variants that are regenerated using the job regenerators as described in the regeneration readme.
- Create a new Regeneration Pipeline for the downstream jobs - https://github.com/adoptium/ci-jenkins-pipelines/blob/master/pipelines/build/regeneration:
Create a new
jdk<new-version-number>_regeneration_pipeline.groovy
. Ensure that thejavaVersion
,targetConfigurations
andbuildConfigurations
variables are what they should be for the new version. Don't remove any old version configs. While you're here, make sure all of the current releases have aregeneration_pipeline.groovy
file (including head). If they don't, create one using the same technique as above.-
Build the
pipeline_jobs_generator
that you just made. Ensure the equivalentopenjdkxx_pipeline
to the generator exists or this will fail. If the job fails or is unstable, search the console log forWARNING
orERROR
messages for why. Once it has completed successfully, the pipeline is ready to go! -
Update the view for the build and test pipeline calendar to include the new version.
- Update the Job Folder - https://ci.adoptium.net/job/build-scripts/job/utils/: The jobs themselves you are looking for are called
At some point in a java version's lifecycle, the JDK version will be maintained in an update repository. The first notification of this will be via mail list in one of two places:
- jdk-dev
- jdk-updates-dev
When this occurs, usually a Temurin committer will create the
jdk<version>u
update repository (example of the JDK11u one) via our Skara mirroring jobs that pull in the commit and tag info from the Mercurial repository. To find out more about Skara and our other mirroring jobs, see https://github.com/adoptium/mirror-scripts.
New Adoptium mirror repository creation, by an Adoptium GitHub Admin:
- Create a new empty repository adoptium/openjdk-jdkNNu
- Rename mirror job from https://ci.adoptium.net/view/git-mirrors/job/git-mirrors/job/git-skara-jdkNN to https://ci.adoptium.net/view/git-mirrors/job/git-mirrors/job/git-skara-jdkNNu
- Update mirror job "Execute shell" to pass jdkNNu as parameter to bash ./skaraMirror.sh jdkNNu
- Run the renamed job twice, first one will fail due to empty repository, 2nd run should succeed.
- Add the Adoptium.md "marker" text file to both branches "dev" and "release".
When the repository has been created, a few changes to the codebase will be necessary where the code references a jdk version but not it's new update version. I.e. jdk11
became jdk11u
when it was moved to an update repository.
If a product is to be moved to an update repository, follow these steps in chronological order to ensure our builds continue to function:
-
ci-jenkins-pipelines: Update the configurations Rename the nightly build targets file (it will be named
jdkxx.groovy
, example here) to bejdkxxu.groovy
. Do the same for the pipeline config file (namedjdkxx_pipeline_config.groovy
, example here). -
ci-jenkins-pipelines: Update version from
jdkxx
tojdkxxu
inside docs/generateBuildMatrix.sh -
ci-jenkins-pipelines: Run on "linux" platform your updated docs/generateBuildMatrix.sh script to generate the updated README.md table to be updated at the end of README.md
-
openjdk-build: Update the
JDKXX_VERSION
fromjdkxx
tojdkxxu
inside the build script constants that is being shifted to an update repository. -
openjdk-build: Update the version from
jdkxx
tojdkxxu
inside .github/workflows/build.yml -
Merge both ci-jenkins-pipelines and openjdk-build Pull Requests.
-
Cancel jdkxx job regenerator that will have just been triggered: job regenerator
-
Rename the jenkins pipeline jobs regenerator job regenerator from
pipeline_jobs_generator_jdkxx
topipeline_jobs_generator_jdkxxu
. Then manually re-build. -
Check the regenerator has created all the new jdkxxu build jobs successfully: build jobs
-
Delete the old jdkxx build jobs folder: https://ci.adoptium.net/job/build-scripts/job/jobs/jdkxx: build jobs
-
Submit a test pipeline build
Occasionally we may have to do an out-of-band release that does not align with a quarterly release from the upstream OpenJDK project. This may occur if there has been a problem with our build process that we missed at GA time, to fix a critical issue, or when a project outside OpenJDK :
- When triggering the pipeline, set
AdoptBuildNumber
to a unique number for the point release (the original will be "blank" so any subsequent point release required should start at "1") - If you used a custom entry in
overridePublishName
when kicking off the GA pipeline, keep it the same as for the GA release - we DO NOT want the filenames changed to include the point number - When running the publish job, you need to use a custom
TAG
in order to publish it to the website with a separate name from what you had initially e.g.jdk-11.0.5+10.1_openj9-0.17.1
(Note the position of the.1
for OpenJ9 releases in that example - it's after the openj9 version but before the OpenJ9 version.
If you need to create a point release with a one-off patch (Usually a cherry pick of something already in the codebase which will go into the next release) use the following process:
- Clone the repository you need to patch (e.g.
git clone [email protected]:adoptium/jdk21u
) - Check out the tag you wish to base it on (e.g.
git checkout jdk-21.0.1+12_adopt
) - Create a branch for the new release (e.g.
git checkout -b jdk-21.0.1+12.1
) - Cherry pick your patches to apply them onto the source
- Create a new
_adopt
tag for the point release (e.g.git tag -a jdk-21.0.1+12.1_adopt
) - Push the branch and tag:
git push origin jdk-21.0.1+12.1 && git push origin jdk-21.0.1+12.1_adopt
- If the patch does not affect tests, create a PR to update testenv.properties in the aqa-tests release branch with the point release version number (Sample PR against v0.9.9-release)
- If the patch does change tests, a new ".1" branch should be created in aqa-tests, based off the release branch, which has the updatre to testenv.properties (If this was needed in the above example, you would create a v0.9.9.1-release branch)
- Run the release-openjdkXX-pipeline with:
- the new
_adopt
tag as thescmReference
additionalConfigureArgs
of--with-version-build=12
(replace 12 with the number after+
but before new new.1
in the version string)- the
aqaReference
updated if step 8 was followd - the desired set of platforms defined in the
targetConfigurations
parameter
- the new