Context Navigation

Release/Procedure

Version 76 (modified by erilem, 12 months ago)
--

OpenLayers Release Procedure

Work In Progress

Let us say that for the release in question, x is the API Version and y the incremental release number.

Checks

To actually start the release process the following conditions must be met:

No open issues in the x.y milestone
All the unit tests pass
PSC approval (a vote must be passed by the SteeringCommittee)

When these conditions are met the initialization step can occur.

Initialization

Create the x.y branch (the release branch):
```
$ git clone git@github.com/openlayers/openlayers
$ git checkout -b x.y
$ git push origin x.y
```
This is a temporary branch, which will be deleted at the very end of the release process.

Once the release branch is created all the changes/commits for that release should be added to this branch. And commits added to the release branch should regularly be merged in the master branch. Here's how:
```
$ git clone git@github.com/openlayers/openlayers
$ git log master..x.y # review what is to be merged
$ git merge x.y
```
Review the tickets that were closed for this release's milestone.
Based on the previous step, create (or review) release notes for the new release.
- Release notes used to be in wiki pages (e.g. Release/2.2/Notes).
- Now in the OpenLayers repository, under the notes directory (e.g. 2.12.md).
- Even though release notes are in GitHub, a Release/x.y/Notes page including a link to the notes in GitHub should be created (e.g. Release/2.12/Notes).
Create milestone x.(y+1) in the issue tracker
Rename milestone x.y to x.y-rc1 in the issue tracker

Release Candidate Iteration Process

The release process is iterative. After initialization the iterative process can start.

The iterative process in pseudo-code:

do {
    Release x.y-rcZ
    Test x.y-rcZ
    Z++
} while (issues in milestone x.y-rcZ);

Release Candidate Cycle `x.y-rcZ`

Verify that milestone x.y-rcZ has no open issues ( https://github.com/openlayers/openlayers/issues/milestones?state=closed)
Compile a Release Announcement. The announcement should be located at Release/x.y/Announce/RCZ and should include one of the following:
- If this is the first RC (Z is 1): A link to the Release/x.y/Notes wiki or the notes/x.y.md file on GitHub , and a brief summary of its contents.
- If this is not the first RC, then: A brief summary of all of the issues that were fixed in the last RC.
Create milestone x.y-rc(Z+1)
Set VERSION_NUMBER in lib/OpenLayers.js and lib/OpenLayers/SingleFile.js to Release x.y-rcZ, and commit the change to the x.y branch.

Create tag release-x.y-rcZ (off the x.y branch)

$ git clone git@github.com/openlayers/openlayers
$ git tag release-x.y-rcZ x.y
$ git push origin release-x.y-rcZ

Actually release x.y-rcZ
```
$ ssh www.openlayers.org
$ # change to user "openlayers"
$ cd /tmp
$ git clone https://github.com/openlayers/openlayers
$ cd openlayers/tools
$ ./release.sh x.y-rcZ
```
- Verify that the archives are available:
  - http://openlayers.org/download/OpenLayers-x.y-rcZ.tar.gz
  - http://openlayers.org/download/OpenLayers-x.y-rcZ.zip
- Verify that the built scripts are available:
Email the Release Announcement to the dev list (subject: ANNOUNCEMENT: OpenLayers x.y RCZ!). CC: the users list if this is the first RC.

Test Cycle `x.y-rcZ`

Users and developers report bugs and create new issues in GitHub.
Core developers watch incoming issues, and dispatch them to appropriate milestones.
- Issues for regressions go to the x.y-rc(Z+1) milestone.
Developers fix regressions, run the tests, and close issues.
- Fixes for issues in the x.y-(Z+1) milestone are committed into the x.y branch.
- And commits added to the x.y branch should regularly be merged in the master branch. Here's how:
```
$ git clone git@github.com/openlayers/openlayers
$ git log master..x.y # review what is to be merged
$ git merge x.y
```
If the x.y-rc(Z+1) milestone has no open issues a core dev may send a proposal email to the dev list calling for:
- A new RC
  - The support of at least one other committer must be obtained.
  - We exit Test Cycle and start a new Release Candidate Cycle with Z=Z+1.
- The Final Release:
  - All issues in the x.y-rcZ milestone must be closed and no new issues opened in the x.y-rc(Z+1) milestone
  - A successful voting round must pass the SteeringCommittee.
  - We exit Test Cycle and Release Candidate Cycle and proceed to the Finalization step.

Finalization

Delete the x.y-rc(Z+1) milestone (the Z+1 RC won't exist)
Update http://trac.osgeo.org/openlayers/wiki/Documentation
Review the notes in the notes dir
Create tag release-x.y (off branch x.y)
Make sure the x.(y+1) milestone has been created in github
Suppress the x.y branch
Reset VERSION_NUMBER in master
Release (release.sh + api docs)
Update HowToDownload wiki with new latest stable api release links.
Email the dev and users lists and announce the release containing:
- A link to the Release/x.y/Notes wiki
- A summary of the major features and bug fixes for the release
Write a 50 word summary of the release and send to news_item at osgeo dot org

OLD AFTER THIS

Creating a Release Candidate

Release Candidate (RC) Cycle
Let us say that for the RC in question, Z is the incremental release candidate number (starting with 1)
1. Compile a Release Announcement. The announcement should be located at Release/x.y/Announce/RCZ and should include one of the following:
  - If this is the first RC (Z is 1): A link to the Release/x.y/Notes wiki, and a brief summary of its contents.
  - If this is not the first RC, then: A brief summary of all of the tickets that were fixed in the last RC.
    This should be a summary of the following trac query (where we let W be the previous RC number, i.e. Z-1):
```
http://trac.openlayers.org/query?status=closed&version=x.y+RCW&milestone=x.y+Release&resolution=fixed&order=priority
```
2. Set VERSION_NUMBER in http://svn.openlayers.org/branches/openlayers/x.y/lib/OpenLayers.js and http://svn.openlayers.org/branches/openlayers/x.y/lib/OpenLayers/SingleFile.js to "Release x.y-rcZ" and commit the change.
3. Create a release tag for the RC (off the release branch):

Export and Build the single file versions:

$ wget -O release-x.y-rcZ.tar.gz https://github.com/openlayers/openlayers/tarball/release-x.y-rcZ
$ tar xvzf release-x.y-rcZ.tar.gz
$ cd openlayers-openlayers-*/tools
$ VERSION=x.y-rcZ ./release.sh

UNCHANGED AFTER THIS LINE

Create a new API release directory on openlayers.org and install the build

  mkdir /www/openlayers/docs/api/x.y-rcZ
  cd ..
  cp build/OpenLayers.js /www/openlayers/docs/api/x.y-rcZ
  cp -a img/ /www/openlayers/docs/api/x.y-rcZ
  cp -a theme/ /www/openlayers/docs/api/x.y-rcZ

Build the tarball and copy it up to openlayers.org

  # First remove all .pyc files from the directory.
  rm tools/*.pyc
  cd ..
  tar cvfz OpenLayers-x.y-rcZ.tar.gz OpenLayers-x.y-rcZ/
  cp OpenLayers-x.y-rcZ.tar.gz /www/openlayers/docs/download

Build a zip archive to openlayers.org

  zip -9r OpenLayers-x.y-rcZ.zip OpenLayers-x.y-rcZ/
  cp OpenLayers-x.y-rcZ.zip /www/openlayers/docs/download

Create a new Version entry in TRAC called "x.y RCZ" for bug tracking
Email the Release Announcement to the dev list.

The Testing Cycle

Testing Cycle -- in which users and developers:
- Report new tickets
  1. Milestone: x.y Release
  2. Version: x.y RCZ
- Fix outstanding tickets:
  1. Commit only to trunk
  2. Set 'State' to 'Pullup' as they still need to be pulled up to the branch
  3. Do not mark as closed (i.e. leave them open)
- Run all tests in both Firefox 1.5 and IE 6.
  - If any tests fail, return to Testing Cycle and report a new ticket.
  - If all tests pass, a committer may send a proposal email to the dev list calling for:
    - A new RC:
      1. The support of at least one other committer must be obtained.
      2. The committer chooses which patches to include in the the new RC or Final Release.
        These should be taken from the the results of the following trac query:
        http://trac.openlayers.org/query?milestone=x.y+Release&keywords=%7Epullup&order=priority
        Bring up each ticket's patch from trunk into the branch
        Change each ticket's 'State' field to 'Complete'
        Add brief summary of the change to the Release/x.y/Notes wiki
        Mark ticket closed
      3. Committer exits Testing Cycle, starts new Release Candidate Cycle
    - The Final Release:
      1. All tickets for the milestone must be closed in the previous RC and no new tickets opened in the current one.
      2. A successful voting round must pass the SteeringCommittee.
      3. SteeringCommittee member exits the Testing Cycle and Release Candidate Cycle and proceeds to the next step, Review the Release/x.y/Notes wiki...

Review the Release/x.y/Notes wiki and make sure it contains important info from all the closed tickets for the Release x.y milestone:
```
http://trac.openlayers.org/query?group=component&milestone=x.y+Release&resolution=fixed&order=priority
```
Update news.txt: both in trunk and in the branch, update the /news.txt file to reflect this release. Note that you must be both tricky and quick here, as you must *predict* the correct revision number for the actual tagging of the release, which you will do in the next step. Essentially, this is current release +2 (one for the check-in of news.txt, one for the tag). It seems absurd, but it is good to make sure that no one else is checking in at the same time as this maneuver assumes a quiet wire.
1. Set VERSION_NUMBER in http://svn.openlayers.org/branches/openlayers/x.y/lib/OpenLayers.js and http://svn.openlayers.org/branches/openlayers/x.y/lib/OpenLayers/SingleFile.js to "Release x.y-rcZ" and commit the change.

Tag the release:

  export VERSION=2.7
  svn copy -m "Tagging the Final x.y Release" http://svn.openlayers.org/branches/openlayers/$VERSION http://svn.openlayers.org/tags/openlayers/release-$VERSION

Export and Build the single file version:

  svn export http://svn.openlayers.org/tags/openlayers/release-$VERSION OpenLayers-$VERSION
  cd OpenLayers-$VERSION/build
  ./build.py