


Apache Felix Dependency Manager Release Guide 
This document describes how to do a source release. It is based on the Release FAQ [1]

Prerequisites
=============

To create a release you must:

* Have Subversion installed on your system;
* Have gpg installed on your system;
* Have a public key added to the keys file, and committed to [2] 
* If you are using an http proxy, configure the following:

  export GRADLE_OPTS="-Dhttps.proxyHost=www.somehost.org -Dhttps.proxyPort=8080"

Before you can start staging a release candidate, you must:

* increment the ext.dmRelease parameter in release/build.gradle, if not already done.
* make sure there are no dependencies on snapshots/unreleased versions;
* create a tagged version of the sources in preparation of the release candidate.

Creating a tagged version of the sources can be done directly through svn (replace r<n> by the actual release number, like "r1"):

svn copy https://svn.apache.org/repos/asf/felix/trunk/dependencymanager https://svn.apache.org/repos/asf/felix/releases/org.apache.felix.dependencymanager-r<n> -m "Release of Apache Felix Dependency Manager r<n>"

Staging a release candidate
===========================

Staging a release starts by checking out a tagged version of the sources (replace r<n> by the actual release number, like "r1"):

svn co https://svn.apache.org/repos/asf/felix/releases/org.apache.felix.dependencymanager-r<n>

The next step is to build/test the software and create the release/staging/ directory (where the source/jars will be packaged):
(replace r<n> by the actual release number, like "r1")

Use a Java7 JDK

$ cd org.apache.felix.dependencymanager-r<n>
$ ./gradlew rat 
$ ./gradlew org.apache.felix.dependencymanager.annotation:jar
$ ./gradlew jar
$ ./gradlew test
$ ./gradlew check

create the staging:

$ ./gradlew makeStaging (this will create ./release/staging/ directory)

Then you sign archives by invoking the following task:

$ ./gradlew signStaging

You can upload the archives and the signatures to our development area, which we use to stage this release candidate. This development area can be found at 
https://dist.apache.org/repos/dist/dev/felix and adding files to it can be done using "svnpubsub" which is taken care of by the following target:

$ ./gradlew commitToStaging

Voting on the release
=====================

Start a vote on the dev@felix.apache.org list, for example (be sure to replace r<n> with the correct release number, like "r1"):

>>>
To: "Felix Developers List" <dev@felix.apache.org>
Subject: [VOTE] Release of Apache Felix Dependency Manager release r<n>

Hi,

We solved N issues in this release:
http://issues.apache.org/jira/...

There are still some outstanding issues:
http://issues.apache.org/jira/...

Staging repository:
https://dist.apache.org/repos/dist/dev/felix/apache-felix-dependencymanager-r<n>/

You can use this UNIX script to download the release and verify the signatures:
http://svn.apache.org/repos/asf/felix/trunk/dependencymanager/release/check_staged_release.sh

Usage:
sh check_staged_release.sh r<n> /tmp/felix-staging

This script, unlike the original Felix check_stage_release.sh, will download staging from https://dist.apache.org/repos/dist/dev/felix instead of 
http://repository.apache.org/content/repositories.


Please vote to approve this release:

[ ] +1 Approve the release
[ ] -1 Veto the release (please provide specific comments)

This vote will be open for 72 hours.
<<<

Promoting the release:
=====================

Move the artifacts from the development area to the final release location at 
https://dist.apache.org/repos/dist/release/felix by invoking the following target:

$ ./gradlew promoteToRelease

Then Edit the ./release/build.gradle script, increment the "ext.dmRelease" property, and commit.

Cancelling the release
======================

$ ./gradlew deleteFromStaging

[1] http://www.apache.org/dev/release.html
[2] http://www.apache.org/dist/felix/KEYS
