<!DOCTYPE html>
<!--
 | Generated by Apache Maven Doxia Site Renderer 1.9.2 at 2021-08-01 
 | Rendered using Apache Maven Fluido Skin 1.6
-->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta name="Date-Revision-yyyymmdd" content="20210801" />
    <meta http-equiv="Content-Language" content="en" />
    <title>Apache Axis2 &#x2013; Release Process</title>
    <link rel="stylesheet" href="./css/apache-maven-fluido-1.6.min.css" />
    <link rel="stylesheet" href="./css/site.css" />
    <link rel="stylesheet" href="./css/print.css" media="print" />
      <script type="text/javascript" src="./js/apache-maven-fluido-1.6.min.js"></script>
      </head>
    <body class="topBarDisabled">
      <div class="container-fluid">
      <div id="banner">
        <div class="pull-left"><a href="http://www.apache.org/" id="bannerLeft"><img src="http://www.apache.org/images/asf_logo_wide.png"  alt="Apache Axis2"/></a></div>
        <div class="pull-right"><a href="./" id="bannerRight"><img src="images/axis.jpg" /></a></div>
        <div class="clear"><hr/></div>
      </div>

      <div id="breadcrumbs">
        <ul class="breadcrumb">
        <li id="publishDate">Last Published: 2021-08-01<span class="divider">|</span>
</li>
          <li id="projectVersion">Version: 1.8.0<span class="divider">|</span></li>
        <li class=""><a href="http://www.apache.org" class="externalLink" title="Apache">Apache</a><span class="divider">/</span></li>
      <li class=""><a href="index.html" title="Axis2/Java">Axis2/Java</a><span class="divider">/</span></li>
    <li class="active ">Release Process</li>
        </ul>
      </div>
      <div class="row-fluid">
        <div id="leftColumn" class="span2">
          <div class="well sidebar-nav">
<ul class="nav nav-list">
          <li class="nav-header">Axis2/Java</li>
    <li><a href="index.html" title="Home"><span class="none"></span>Home</a>  </li>
    <li><a href="download.html" title="Downloads"><span class="none"></span>Downloads</a>  </li>
    <li><a href="javascript:void(0)" title="Release Notes"><span class="icon-chevron-down"></span>Release Notes</a>
      <ul class="nav nav-list">
    <li><a href="release-notes/1.6.1.html" title="1.6.1"><span class="none"></span>1.6.1</a>  </li>
    <li><a href="release-notes/1.6.2.html" title="1.6.2"><span class="none"></span>1.6.2</a>  </li>
    <li><a href="release-notes/1.6.3.html" title="1.6.3"><span class="none"></span>1.6.3</a>  </li>
    <li><a href="release-notes/1.6.4.html" title="1.6.4"><span class="none"></span>1.6.4</a>  </li>
    <li><a href="release-notes/1.7.0.html" title="1.7.0"><span class="none"></span>1.7.0</a>  </li>
    <li><a href="release-notes/1.8.0.html" title="1.8.0"><span class="none"></span>1.8.0</a>  </li>
      </ul>
  </li>
    <li><a href="modules/index.html" title="Modules"><span class="none"></span>Modules</a>  </li>
    <li><a href="tools/index.html" title="Tools"><span class="none"></span>Tools</a>  </li>
          <li class="nav-header">Documentation</li>
    <li><a href="docs/toc.html" title="Table of Contents"><span class="none"></span>Table of Contents</a>  </li>
    <li><a href="docs/installationguide.html" title="Installation Guide"><span class="none"></span>Installation Guide</a>  </li>
    <li><a href="docs/quickstartguide.html" title="QuickStart Guide"><span class="none"></span>QuickStart Guide</a>  </li>
    <li><a href="docs/userguide.html" title="User Guide"><span class="none"></span>User Guide</a>  </li>
    <li><a href="docs/jaxws-guide.html" title="JAXWS Guide"><span class="none"></span>JAXWS Guide</a>  </li>
    <li><a href="docs/pojoguide.html" title="POJO Guide"><span class="none"></span>POJO Guide</a>  </li>
    <li><a href="docs/spring.html" title="Spring Guide"><span class="none"></span>Spring Guide</a>  </li>
    <li><a href="docs/webadminguide.html" title="Web Administrator's Guide"><span class="none"></span>Web Administrator's Guide</a>  </li>
    <li><a href="docs/migration.html" title="Migration Guide (from Axis1)"><span class="none"></span>Migration Guide (from Axis1)</a>  </li>
          <li class="nav-header">Resources</li>
    <li><a href="faq.html" title="FAQ"><span class="none"></span>FAQ</a>  </li>
    <li><a href="articles.html" title="Articles"><span class="none"></span>Articles</a>  </li>
    <li><a href="http://wiki.apache.org/ws/FrontPage/Axis2/" class="externalLink" title="Wiki"><span class="none"></span>Wiki</a>  </li>
    <li><a href="refLib.html" title="Reference Library"><span class="none"></span>Reference Library</a>  </li>
    <li><a href="apidocs/index.html" title="Online Java Docs"><span class="none"></span>Online Java Docs</a>  </li>
          <li class="nav-header">Get Involved</li>
    <li><a href="overview.html" title="Overview"><span class="none"></span>Overview</a>  </li>
    <li><a href="git.html" title="Checkout the Source"><span class="none"></span>Checkout the Source</a>  </li>
    <li><a href="mail-lists.html" title="Mailing Lists"><span class="none"></span>Mailing Lists</a>  </li>
    <li class="active"><a href="#"><span class="none"></span>Release Process</a>
  </li>
    <li><a href="guidelines.html" title="Developer Guidelines"><span class="none"></span>Developer Guidelines</a>  </li>
    <li><a href="siteHowTo.html" title="Build the Site"><span class="none"></span>Build the Site</a>  </li>
          <li class="nav-header">Project Information</li>
    <li><a href="team-list.html" title="Project Team"><span class="none"></span>Project Team</a>  </li>
    <li><a href="issue-tracking.html" title="Issue Tracking"><span class="none"></span>Issue Tracking</a>  </li>
    <li><a href="https://github.com/apache/axis-axis2-java-core/" class="externalLink" title="Source Code"><span class="none"></span>Source Code</a>  </li>
    <li><a href="thanks.html" title="Acknowledgements"><span class="none"></span>Acknowledgements</a>  </li>
          <li class="nav-header">Apache</li>
    <li><a href="http://www.apache.org/licenses/LICENSE-2.0.html" class="externalLink" title="License"><span class="none"></span>License</a>  </li>
    <li><a href="http://www.apache.org/foundation/sponsorship.html" class="externalLink" title="Sponsorship"><span class="none"></span>Sponsorship</a>  </li>
    <li><a href="http://www.apache.org/foundation/thanks.html" class="externalLink" title="Thanks"><span class="none"></span>Thanks</a>  </li>
    <li><a href="http://www.apache.org/security/" class="externalLink" title="Security"><span class="none"></span>Security</a>  </li>
  </ul>
          <hr />
          <div id="poweredBy">
              <div class="clear"></div>
              <div class="clear"></div>
              <div class="clear"></div>
              <div class="clear"></div>
  <a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy"><img class="builtBy" alt="Built by Maven" src="./images/logos/maven-feather.png" /></a>
              </div>
          </div>
        </div>
        <div id="bodyColumn"  class="span10" >
<!--
  ~ 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.
  -->
<h1>Release Process</h1><section>
<h2><a name="Release_process_overview"></a>Release process overview</h2><section>
<h3><a name="Cutting_a_branch"></a>Cutting a branch</h3>
<ul>

<li>

<p>When a release is ready to go, release manager (RM) puts forward a release plan as per standard Apache process, including dates. This gets VOTEd on by the committers. During this period the trunk is still the only relevant source base.</p>
</li>
<li>

<p>As soon as a release is approved (or even before), RM should add the new version into JIRA as a target.</p>
</li>
<li>

<p>At the point where we would normally do the &#x201c;code freeze&#x201d; for a release, the RM cuts a branch named for the release. This branch is where the release candidates and releases will happen.</p>
</li>
<li>

<p>Ideally a release branch is only around for a week or maybe two before the release happens.</p>
</li>
<li>

<p>The only things that should EVER get checked into the release branch are - 1) bug fixes targeted at the release, 2) release-specific updates (documentation, SNAPSHOT removal, etc). In particular new functionality does not go here unless it is a solution to a JIRA report targeted at the release.</p>
</li>
<li>

<p>Normal development continues on the trunk.</p>
</li>
</ul></section><section>
<h3><a name="Dependencies_and_branches"></a>Dependencies and branches</h3>
<ul>

<li>

<p>The trunk should always be &#x201c;cutting edge&#x201d; and as such should usually be pointing at SNAPSHOT versions of all dependencies. This allows for continuous integration with our partner projects.</p>
</li>
<li>

<p>Soon after a release branch is cut, the RM is responsible for removing ALL dependencies on SNAPSHOT versions and replacing them with officially released versions. This change happens only on the release branch.</p>
</li>
</ul></section><section>
<h3><a name="Managing_change_and_issue_resolution_with_a_release_branch"></a>Managing change and issue resolution with a release branch</h3>
<ul>

<li>

<p>The RM goes through JIRA issues and sets &#x201c;fix for&#x201d; to point to both &#x201c;NIGHTLY&#x201d; and the new branched release number for the fixes that are targeted for the release after the branch is cut.</p>
</li>
<li>

<p>In general, the assignee/coder fixes JIRA issues or makes other changes <i>on the trunk</i>. If the JIRA issue is targeted at the release, or upon coder&#x2019;s discretion, they then merge the fix over to the release branch.</p>
</li>
<li>

<p>This way the trunk is ALWAYS up-to-date, and we don&#x2019;t have to worry about losing fixes that have only been made on the release branch.</p>
</li>
<li>

<p>When the assignee resolves an issue, they confirm it&#x2019;s been fixed in both branches, if appropriate.</p>
</li>
</ul></section><section>
<h3><a name="Checking_changes_into_the_branch"></a>Checking changes into the branch</h3>
<ul>

<li>

<p>If bug fixes are needed later for a release which has long since happened (to fix user issues, etc), those fixes generally should also happen on the trunk first assuming the problem still exists on the trunk.</p>
</li>
<li>

<p>There are only two cases where we would ever check anything into the branch without first checking it into the trunk. 1) Release specific items (release number references, release notes, removal of SNAPSHOTs), and 2) if the trunk has moved on in some incompatible way.</p>
</li>
</ul></section></section><section>
<h2><a name="Performing_a_release"></a>Performing a release</h2><section>
<h3><a name="Preparation"></a>Preparation</h3>
<p>Verify that the code meets the basic requirements for being releasable:</p>
<ol style="list-style-type: decimal">

<li>

<p>Check that the set of legal (<code>legal/*.LICENSE</code>) files corresponds to the set of third party JARs included in the binary distribution.</p>
</li>
<li>

<p>Check that the <code>apache-release</code> profile works correctly and produces the required distributions. The profile can be executed as follows:</p>

<div class="source">
<div class="source"><pre class="prettyprint">mvn clean install -Papache-release
</pre></div></div>
</li>
<li>

<p>Check that the source distribution is buildable.</p>
</li>
<li>

<p>Check that the source tree is buildable with an empty local Maven repository.</p>
</li>
</ol>
<p>If any problems are detected, they should be fixed on the trunk (except for issues specific to the release branch) and then merged to the release branch.</p>
<p>Next update the release note found under <code>src/site/markdown/release-notes</code>. To avoid extra work for the RM doing the next major release, these changes should be done on the trunk first and then merged to the release branch.</p></section><section>
<h3><a name="Pre-requisites"></a>Pre-requisites</h3>
<p>The following things are required to perform the actual release:</p>
<ul>

<li>

<p>A PGP key that conforms to the <a class="externalLink" href="http://www.apache.org/dev/release-signing.html">requirements for Apache release signing</a>. To make the release process easier, the passphrase for the code signing key should be configured in <code>${user.home}/.m2/settings.xml</code>:</p>

<div class="source">
<div class="source"><pre class="prettyprint">&lt;settings&gt;
  ...
  &lt;profiles&gt;
    &lt;profile&gt;
      &lt;id&gt;apache-release&lt;/id&gt;
      &lt;properties&gt;
        &lt;gpg.passphrase&gt;&lt;!-- key passphrase --&gt;&lt;/gpg.passphrase&gt;
      &lt;/properties&gt;
    &lt;/profile&gt;
  &lt;/profiles&gt;
  ...
&lt;/settings&gt;
</pre></div></div>
</li>
<li>

<p>The release process uses a Nexus staging repository. Every committer should have access to the corresponding staging profile in Nexus. To validate this, login to <a class="externalLink" href="https://repository.apache.org">repository.apache.org</a> and check that you can see the <code>org.apache.axis2</code> staging profile. The credentials used to deploy to Nexus should be added to <code>settings.xml</code>:</p>

<div class="source">
<div class="source"><pre class="prettyprint">&lt;servers&gt;
  ...
  &lt;server&gt;
    &lt;id&gt;apache.releases.https&lt;/id&gt;
    &lt;username&gt;&lt;!-- ASF username --&gt;&lt;/username&gt;
    &lt;password&gt;&lt;!-- ASF LDAP password --&gt;&lt;/password&gt;
  &lt;/server&gt;
  ...
&lt;/servers&gt;
</pre></div></div>
</li>
</ul></section><section>
<h3><a name="Release"></a>Release</h3>
<p>In order to prepare the release artifacts for vote, execute the following steps:</p>
<ol style="list-style-type: decimal">

<li>

<p>Start the release process using the following command:</p>

<div class="source">
<div class="source"><pre class="prettyprint">mvn release:prepare
</pre></div></div>

<p>When asked for a tag name, accept the default value (in the following format: <code>vX.Y.Z</code>). The execution of the <code>release:prepare</code> goal may occasionally fail because <code>svn.apache.org</code> resolves to one of the geolocated SVN mirrors and there is a propagation delay between the master and these mirrors. If this happens, wait for a minute (so that the mirrors can catch up with the master) and simply rerun the command. It will continue where the error occurred.</p>
</li>
<li>

<p>Perform the release using the following command:</p>

<div class="source">
<div class="source"><pre class="prettyprint">mvn release:perform
</pre></div></div>
</li>
<li>

<p>Login to Nexus and close the staging repository. For more details about this step, see <a class="externalLink" href="https://docs.sonatype.org/display/Repository/Closing+a+Staging+Repository">here</a>.</p>
</li>
<li>

<p>Execute the <code>target/checkout/etc/dist.py</code> script to upload the distributions.</p>
</li>
<li>

<p>Create a staging area for the Maven site:</p>

<div class="source">
<div class="source"><pre class="prettyprint">git clone https://gitbox.apache.org/repos/asf/axis-site.git
cd axis-site
cp -r axis2/java/core/ axis2/java/core-staging
git add  axis2/java/core-staging
git commit -am &quot;core-staging&quot;
git push
</pre></div></div>
</li>
<li>

<p>Change to the <code>target/checkout</code> directory and prepare the site using the following commands:</p>

<div class="source">
<div class="source"><pre class="prettyprint">mvn site-deploy
mvn scm-publish:publish-scm -Dscmpublish.skipCheckin=true
</pre></div></div>

<p>Now go to the <code>target/scmpublish-checkout</code> directory (relative to <code>target/checkout</code>) and check that there are no unexpected changes to the site. Then commit the changes.</p>
</li>
<li>

<p>Start the release vote by sending a mail to <code>java-dev@axis.apache.org</code>. The mail should mention the following things:</p>
<ul>

<li>A link to the Nexus staging repository.</li>
<li>A link to the directory containing the distributions (<a class="externalLink" href="https://dist.apache.org/repos/dist/dev/axis/axis2/java/core/x.y.x/">https://dist.apache.org/repos/dist/dev/axis/axis2/java/core/x.y.x/</a>).</li>
<li>A link to the preview of the Maven site (<a class="externalLink" href="http://axis.apache.org/axis2/java/core-staging/">http://axis.apache.org/axis2/java/core-staging/</a>).</li>
</ul>
</li>
</ol>
<p>If the vote passes, execute the following steps:</p>
<ol style="list-style-type: decimal">

<li>

<p>Promote the artifacts in the staging repository. See <a class="externalLink" href="https://central.sonatype.org/publish/release/#close-and-drop-or-release-your-staging-repository">here</a> for detailed instructions for this step.</p>
</li>
<li>

<p>Publish the distributions:</p>

<div class="source">
<div class="source"><pre class="prettyprint">svn mv https://dist.apache.org/repos/dist/dev/axis/axis2/java/core/x.y.z \
       https://dist.apache.org/repos/dist/release/axis/axis2/java/core/
</pre></div></div>
</li>
<li>

<p>Publish the site:</p>

<div class="source">
<div class="source"><pre class="prettyprint">svn co --depth=immediates https://svn.apache.org/repos/asf/axis/site/axis2/java/ axis2-site
cd axis2-site
svn rm core
svn mv core-staging core
svn commit
</pre></div></div>
</li>
</ol>
<p>It may take several hours before everything has been synchronized. Before proceeding, check that</p>
<ul>

<li>the Maven artifacts for the release are available from the Maven central repository;</li>
<li>the Maven site has been synchronized;</li>
<li>the distributions can be downloaded from the mirror sites.</li>
</ul>
<p>Once everything is in place, send announcements to <code>java-user@axis.apache.org</code> (with copy to <code>java-dev@axis.apache.org</code>) and <code>announce@apache.org</code>. Since the two lists have different conventions, audiences and moderation policies, it is recommended to send the announcement separately to the two lists. Note that mail to <code>announce@apache.org</code> must be sent from an <code>apache.org</code> address and will always be moderated. The announcement sent to <code>announce@apache.org</code> also should include a general description of Axis2, because not everybody subscribed to that list knows about the project.</p></section><section>
<h3><a name="Post-release_actions"></a>Post-release actions</h3>
<ol style="list-style-type: decimal">

<li>

<p>Update the DOAP file (<code>etc/doap_Axis2.rdf</code>) and add a new entry for the release.</p>
</li>
<li>

<p>Update the status of the release version in JIRA.</p>
</li>
<li>

<p>Remove old (archived) releases from <a class="externalLink" href="https://dist.apache.org/repos/dist/release/axis/axis2/java/core/">https://dist.apache.org/repos/dist/release/axis/axis2/java/core/</a>.</p>
</li>
<li>

<p>Create an empty release note for the next release under <code>src/site/markdown/release-notes</code>.</p>
</li>
</ol></section></section>
        </div>
      </div>
    </div>
    <hr/>
    <footer>
      <div class="container-fluid">
        <div class="row-fluid">
            <p>Copyright &copy;2004&#x2013;2021
<a href="https://www.apache.org/">The Apache Software Foundation</a>.
All rights reserved.</p>
        </div>
        </div>
    </footer>
    </body>
</html>
