 ----
 Releasing NPanday
 ----
~~Licensed to the Apache Software Foundation (ASF) under one
~~or more contributor license agreements.  See the NOTICE file
~~distributed with this work for additional information
~~regarding copyright ownership.  The ASF licenses this file
~~to you under the Apache License, Version 2.0 (the
~~"License"); you may not use this file except in compliance
~~with the License.  You may obtain a copy of the License at
~~
~~    http://www.apache.org/licenses/LICENSE-2.0
~~
~~Unless required by applicable law or agreed to in writing,
~~software distributed under the License is distributed on an
~~"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~KIND, either express or implied.  See the License for the
~~specific language governing permissions and limitations
~~under the License.

Pre-release checklist

  * Check the build is successful for both NPanday and NPanday-ITs

  * Ensure all issues in the JIRA for that version have been resolved, or are moved to a later version
  
  * NPanday staging repo {{http://vmbuild.apache.org/archiva/repository/staged-npanday/}} should be re-created before the release to ensure that the repo only contains the 
    artifacts for the said release version.

  
  * Make sure that the copyright and licenses are on all source code
  
  To do this, run the following command:
  
+----+
mvn clean install -Ppre-release
+----+

  Ensure that the build is successful before proceeding to the release proper.
  <Note: (This is needed for the signature of the artifacts to be deployed)>
  
  * The release manager should generate a sign key and register the key at http://pgp.mit.edu/
  
  * Be sure that the key was already VERIFIED for integrity puposes
  
  * The following configuration should be added in the settings.xml:

+------+  
<profile>
  <id>npanday-releases</id>
  <properties>
    <gpg.passphrase>PASSPHRASE_CREATED</gpg.passphrase>
  </properties>
</profile>
+------+

  []

Creating a Release Candidate

  Send a proposal in the discussion forum regarding the release and the issues that would be fix in the said release.

  The release will be done using the command line. You must release the ITs
  before NPanday (or peg the runner to an older version).
  
* Steps in releasing NPanday-ITs

  [[1]] Check out the code from {{https://svn.apache.org/repos/asf/incubator/npanday/npanday-its/trunk/}}

  [[2]] Run the following command:

+----+
mvn release:prepare
+----+

  [[3]] Fill in the following values: 

   * the release version should ve <<<1.4.1-incubating>>> or similar (use the release version)

   * the SCM tag should be <<<npanday-its-1.4.1-incubating>>> or similar (use the release version)
     
   * check the values for the <Release version> and <Next development version> are correct
  
  [[4]] Check if the tag was successfully created in {{https://svn.apache.org/repos/asf/incubator/npanday/npanday-its/tags/}}
  
  [[5]] After successful release:prepare, run the following command:

+----+
mvn release:perform
+----+

* Steps in releasing NPanday:

  [[1]] Check out the code from {{https://svn.apache.org/repos/asf/incubator/npanday/trunk//}}
  
  [[2]] Run the following command:
  
----
mvn release:prepare -Pdist,run-its
----

  [[3]] Fill in the following values:
  
   * the release version should be <<<1.4.1-incubating>>> or similar (use the release version)
     
   * the SCM tag should be <<<npanday-1.4.1-incubating>>> or similar (use the release version)
     
   * check the values for the <Release version> and <Next development version> are correct	 
  
  [[4]] Check if the tag was successfully created in {{https://svn.apache.org/repos/asf/incubator/npanday/tags/}}
  
  [[5]] After successful release:prepare, run the following command:

----
mvn release:perform
----

  To verify if the release was successful, check that the artifacts has been populated in {{http://vmbuild.apache.org/archiva/repository/staged-npanday/}}

Testing the Release Candidate

  Announce the RC and the community will be given a 72hr window to test. If the RC passes, same process would be done
  for the final version. eg. <<<1.4.1-incubating>>>.

Voting on the Release

  After the 72 hr window for testing, send out an email to the dev list <<<npanday-dev@incubator.apache.org>>> for the official <<VOTE>> that would be open for 72 hours.  
  
  <<Note:>> If the project is still under incubator, send out an email to the incubator PMC <<<general@incubator.apache.org>>> for approval of the release.

Finalising the Release

  After the approval of the developers:

    * {{{./publishing-docs.html} Publish the site}} for the released version

    * Binaries and sources should be copied to <<<//www/www.apache.org/dist/incubator/npanday/>>>.

    * Artifacts should be merged and synched to ibiblio by executing the ff command:
    
----
mvn stage:copy -Dsource="http://vmbuild.apache.org/archiva/repository/staged-npanday/" -Dtarget="scp://[APACHE_USERNAME]@people.apache.org/www/people.apache.org/repo/m2-ibiblio-rsync-repository" 
-Dversion=1.4.1-incubating -DrepositoryId=apache.releases
----

    * Send out an announcement of the release to:

        ** npanday-users@incubator.apache.org

        ** announce@apache.org


    []

  <<Note:>> If a serious flaw is found in the release, the release version will not be removed in the distribution list
            but instead a new release (1.4.2-incubating) should be provided.
