Context Navigation

Release/Procedure/New

Version 14 (modified by euzuro, 7 years ago)
--

OpenLayers Release Procedure

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

Push all remaining open tickets out of the current release's milestone. A Release procedure must be started with all the milestone's tickets closed.
A vote must be passed by the SteeringCommittee to start a new release procedure.

Create a new branch

  svn copy /trunk/openlayers /branches/openlayers/x.y

Create a new API release directory

  mkdir /www/openlayers/htdocs/api/x.y-rc1

Make a Trac query to see a list of all the tickets that were closed for this release's milestone.
```
http://trac.openlayers.org/query?milestone=x.y+Release&resolution=fixed&order=component
```
Based on the list from the previous step, create a new ReleaseNotes wiki for the new release. The wiki should be named ReleaseNotes/x.y.
For a good example, see Release/2.2/Notes
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 include one of the following:
  - If this is the first RC (Z is 1)
    - A link to the ReleaseNotes/x.y 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
```
    - A list of all the remaining, unclosed tickets in the milestone.
      This can be copied directly from the following trac query:
```
http://trac.openlayers.org/query?status=new&status=assigned&status=reopened&milestone=x.y+Release&order=priority
```
2. Give the Release Announcement and the Release Candidate to the official MetaCartaOpenLayersRepresentative for inspection. (Until MetaCarta transfers OpenLayers copyright to a community host.)
  - If approval is not granted, the conflicting code must be removed. Do not release the RC. Instead, file the appropriate tickets and proceed straight to the Testing Cycle.
3. Replace all instances in the lib directory of "http://svn.openlayers.org/trunk/openlayers/repository-license.txt" with "http://svn.openlayers.org/trunk/openlayers/release-license.txt"
4. Tag the release:
```
  svn cp http://svn.openlayers.org/branches/openlayers/x.y http://svn.openlayers.org/tags/openlayers/release-x.y-rcZ
```
5. Export it:
```
  svn export http://svn.openlayers.org/tags/openlayers/release-x.y-rcZ OpenLayers-x.y-rcZ
```
6. Build the single file version:
```
  cd OpenLayers-x.y-rcZ/build
  ./build.sh
```
7. Install the new API code on openlayers.org
```
  cd ..
  cp build/OpenLayers.js /www/openlayers/htdocs/api/x.y-rcZ
  cp -a img/ /www/openlayers/htdocs/api/x.y-rcZ
  cp -a theme/ /www/openlayers/htdocs/api/x.y-rcZ
```
8. Remove all .pyc files from the directory.
```
  rm tools/*.pyc
```
9. Build the tarball
```
  cd ../..
  tar cvfz OpenLayers-x.y.tar.gz 
```
10. Copy the tarball up to openlayers.org
```
  cp OpenLayers-x.y.tar.gz /www/openlayers/htdocs/download
```
11. Email the Release Announcement to the dev list
12. 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. Add brief summary of the change to the ReleaseNotes/x.y wiki
    3. Mark keyword pullup as they still need to be pulled up to the branch
    4. 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
      1. Report new ticket
        Milestone: x.y Release
        Version: x.y RCZ
      2. Return to Testing Cycle
    - If all tests pass, a committer 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.
        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
        Remove pullup keyword from ticket
        Mark ticket closed
        Committer exits Testing Cycle, starts new Release Candidate Cycle
      - The Final Release:
        All tickets for the milestone must be closed in the previous RC and no new tickets opened in the current one.
        A successful voting round must pass the SteeringCommittee.
        SteeringCommittee member exits the Testing Cycle and Release Candidate Cycle and proceeds to the next step, Install the new API code on openlayers.org
Review the ReleaseNotes/x.y 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
```
Give the Final Release Candidate to the official MetaCartaOpenLayersRepresentative for inspection. (Until MetaCarta transfers OpenLayers copyright to a community host.)
- If approval is not granted, tickets must be filed and return to start a new Testing Cycle
Replace all instances in the lib directory of "http://svn.openlayers.org/trunk/openlayers/repository-license.txt" with "http://svn.openlayers.org/trunk/openlayers/release-license.txt"

Install the new API code on openlayers.org

  ln -sf x.y/OpenLayers.js /www/openlayers/htdocs/api
  ln -sf x.y/img /www/openlayers/htdocs/api
  ln -s  /www/openlayers.org/htdocs/api/x.y/ /www/openlayers.org/htdocs/api/x/

Email the dev and users lists and announce the release containing:
- A link to the ReleaseNotes/x.y wiki
- A summary of the major features and bug fixes for the release

Download in other formats:

Plain Text