Release Process

Some notes on how Roller releases are orchestrated.

The Release Cycle

Roller releases are made on an as needed basis. Here's an overview of the release cycle.

When a Roller committer would like to make a release at some point in the future, he/she simply proposes that release to the Roller mailing list. After gaining some consensus that a release is needed, a committer should then create a release proposal page on the Roller Wiki which specifies which new features will be in the release.

After some of the planned features are added, a committer may propose a milestone build. Milestone builds are not official releases, each is just a snapshot, so formal vote is not required, only lazy consensus. They may be tagged in SVN and are made available via informal mechanisms, e.g. a committers people.apache.org space. They are meant for testing only and not intended for production use, so there will be no migration scripts to help folks migrate data from milestone M1 to M2, etc.

Once a committer feels that the release is completely ready, he/she proposes to start making release candidates. A release candidate is a complete release, signed and ready to be shipped. Like milestone releases, release candidates are not official releases. They are meant for testing only and not intended for production use. After some feedback and testing has occurred and a release candidate appears to be good for final release, a vote is called. Once there are three +1 votes from PMC members the release can be made.

That's the overview, now let's talk details.

Contributing to a release

If you want to add a feature to a release, you should create a JIRA issue describing the feature, assign it to yourself, and set the "fix-for" field for the release you want. (see the roadmap view in JIRA). For all but the smallest improvements and bug fixes, you should also write a proposal and get it reviewed by the community on the development mailing list. If you are working on a feature marked as IN-PROGRESS in JIRA, then when you are done you should mark it as RESOLVED. Any work that is completed should be properly documented (user guide and/or install guide), change lists should be updated, and if needed database scripts are updated and tested.

Release Numbers and Versions

Roller follows the typical Major.Minor.Patch version numbering convention.

Major releases

A major release is noted by a change in the major release number (i.e. 1.x to 2.x). major releases are like any other Roller release except that they are expected to include potential database schema changes and for that reason the upgrade procedure may be longer and more involved. major releases are also expected to contain larger sets of changes and more complex feature additions which were too large to complete in a minor release.

Minor releases

A minor release is noted by a change in the minor release number (i.e. 1.2 to 1.3). minor releases typically contain smaller changes to the code base and can be easily upgraded. Roller users should feel very comfortable about upgrading their Roller installation with a new minor release.

Patch releases (emergency bug fixes)

We expect that each release of roller will simply be considered a minor release, however should something unfortunate happen and we must do an emergency bug fix for a given release then we may mark that release with an incremental patch version number (i.e. 1.3.1). this is not expected to happen often.

Where Work Gets Done

This section tells you where the right place is for your code and in general how the Roller repository is structured.

Roller Trunk

The Roller trunk is the main development repository and will try to always represent the version of the code base currently being developed for the next release. Each new release will be made from the trunk and distributed as appropriate. It is expected that any code commited to the trunk will be in full working order _in time for the next scheduled release_

Roller Release branch

At some point while we are making release candidates for a Roller release, we may decide to create a branch for the release. We do this in cases where it is very important that post-release development continue in the trunk.

Custom branches

A custom branch can be created whenever a feature is in development that is not on a certain schedule. this allows the custom branch to worked at whatever pace is desired and when the code is ready it can be applied to whatever branch is most appropriate.

An Example

Let's assume that Roller has just recently released version 2.0 and the code repository is as follows ...

branches/roller_1.0 (the old 1.x branch currently representing roller 1.3)
branches/roller_1.1 (the old 1.x branch currently representing roller 1.3)
trunk (now representing roller 2.1 in progress)

Matt has some code he has done to implement Acegi security, but he isn't sure it's going to be ready for the 2.1 release so he gets a custom branch.

branches/roller_acegi (acegi development work by Matt)

Dave and Allen finish up the 2.1 dev work and do a new release

trunk (now represents 2.2 dev work)

Somebody finds a horrible bug in 1.1 (the last 1.x release) and decides it's worth taking the time to do a fix and release 1.1.1 from that branch.

branches/roller_1.1 (now represents potential 1.1.1 release)

Matt feels comfortable that the Acegi stuff is ready, so the acegi branch is put into the current trunk so it'll go into the 2.2 release.

trunk (represents 2.2 dev work, with Matt's acegi code)
branches/roller_acegi (removed, no longer necessary)

Anil has some cool tag related feature to work on, but it requires a db change so he will work from the 3.x branch. Meanwhile, Dave, Allen, and Matt finish up the 2.2 code and do the release.

branches/roller_3.0 (anil doing tag work)
trunk (now represents 2.3 dev work)

Anil says his tag stuff will be ready within the month and the team agrees that now is a good time for a major release.

branches/roller_2.2 (created from trunk after last 2.2 release, represents potential 2.2.1 release)
trunk (now represents 3.0 release, includes Anil's tag work)
branches/roller_4.0 (created for new major release work)

Step-by-step How to Create a Release

NOTE: these instructions are for the Roller 5.0 branch and with Roller 5.1 (yet to be released) these instructions will change.

1. Obtain and update the source code.

Check out the Apache Roller source code from the appropriate branch. Within the pom files, update the Roller version the new number you will be releasing. Update the version within the three sign*.sh files to that version as well.

2. Create release for Tomcat

The commands below will create the Roller for Tomcat release bundle in ZIP and Gzipped TAR formats and the ASCii signature files:

   ./build-tomcat-release.sh
   ./sign-tomcat-release.sh

Once done, move the four files (tar/gz & .asc for them) outside of weblogger-assembly/target folder (otherwise, those files will be lost in the Java EE build in the next step).

3. Create release for Java EE

The commands below will create the Roller for Java EE release bundle in ZIP and Gzipped TAR formats and the ASCii signature files:

   ./build-javaee-release.sh
   ./sign-javaee-release.sh

After that, files will be in the roller/dist directory.

4. Upload files for review

Upload to your home directory the files on people.apache.org, for example for RC1 you might put them here:

   /home/<username>/public_html/rc1

5. Vote on release

Call for a release vote and once the release is approved, move to the next step.

6. Move release files into place

Login to people.apache.org and move the release files into the directory tree in the right place. For example, for a Roller 5.0.4 release files would go under the roller-5 directory.

   /www/www.apache.org/dist/roller/roller-5/v5.0.4/src
   /www/www.apache.org/dist/roller/roller-5/v5.0.4/docs
   /www/www.apache.org/dist/roller/roller-5/v5.0.4/bin

Wait 24 hours for mirrors to update. Once that happens you should delete the old release files for previous versions of Roller. They are already archived elsewhere by the infrastructure team.

7. Update the website to point to the new files

Update the website files in SVN and update to publish.

8. Announce the release

Make the announcement on the mailing list and other places.

Child pages