<!DOCTYPE html>
<html lang="en">
<head>
<!--
    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.
-->
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link href="/css/bootstrap.min.css" rel="stylesheet">
<link href="/css/bootstrap-theme.min.css" rel="stylesheet">
<link href="/css/dataTables.bootstrap.css" rel="stylesheet">
<link href="/css/pirk.css" rel="stylesheet" type="text/css">
<link href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.css" rel="stylesheet">

<title>Making a Release</title>

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
<script src="/js/bootstrap.min.js"></script>
<script src="/js/jquery.dataTables.min.js"></script>
<script src="/js/dataTables.bootstrap.js"></script>
<script>
  // show location of canonical site if not currently on the canonical site
  $(function() {
    var host = window.location.host;
    if (typeof host !== 'undefined' && host !== 'pirk.incubator.apache.org') {
      $('#non-canonical').show();
    }
  });

  
  // decorate menu with currently navigated page
  $(function() {
    $("#nav_releasing").addClass("active");
  });
  

  $(function() {
    // decorate section headers with anchors
    return $("h2, h3, h4, h5, h6").each(function(i, el) {
      var $el, icon, id;
      $el = $(el);
      id = $el.attr('id');
      icon = '<i class="fa fa-link"></i>';
      if (id) {
        return $el.append($("<a />").addClass("header-link").attr("href", "#" + id).html(icon));
      }
    });
  });

  // configure Google Analytics
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-81114308-1', 'auto');
  ga('send', 'pageview');
  
</script>
</head>
<body style="padding-top: 100px">

  <nav class="navbar navbar-default navbar-fixed-top">
  <div class="container-fluid">
    <div class="navbar-header">
      <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar-items">
        <span class="sr-only">Toggle navigation</span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
      </button>
      <a href="/"><img id="nav-logo" alt="Apache Pirk" class="img-responsive" src="/images/pirkImage.png" width="150"/></a>
    </div>
    <div class="collapse navbar-collapse" id="navbar-items">
      <ul class="nav navbar-nav">
        <li class="nav-link"><a href="/downloads">Download</a></li>
        <li class="dropdown">
        <a class="dropdown-toggle" data-toggle="dropdown" href="#">Documentation<span class="caret"></span></a>
        <ul class="dropdown-menu">
          <li id="nav_users"><a href="/for_users">For Users</a></li>
          <li id="nav_developers"><a href="/for_developers">For Developers</a></li>
          <li id="nav_developers"><a href="/cloud_instructions">Cloud instructions</a></li>
          <li id="nav_papers"><a href="/papers">Papers &amp Presentations</a></li>
          <li class="nav_faq"><a href="/faq">FAQ</a></li>
          <li class="divider"></li>
           <li><a href="/javadocs">Javadocs</a></li>     
        </ul>
        </li>
        <li class="dropdown">
        <a class="dropdown-toggle" data-toggle="dropdown" href="#">Community<span class="caret"></span></a>
        <ul class="dropdown-menu">
          <li id="nav_getinvolvedpirk"><a href="/get_involved_pirk">Get Involved</a></li>
          <li id="nav_listspirk"><a href="/mailing_list_pirk">Mailing Lists</a></li>
          <li id="nav_peoplepirk"><a href="/people_pirk">People</a></li>
       	</ul>
        </li>
        <li class="dropdown">
        <a class="dropdown-toggle" data-toggle="dropdown" href="#">Development<span class="caret"></span></a>
        <ul class="dropdown-menu">
          <li id="nav_releasing"><a href="/how_to_contribute">How to Contribute</a></li>
          <li id="nav_releasing"><a href="/releasing">Making Releases</a></li>
          <li id="nav_nav_verify_release"><a href="/verifying_releases">Verifying Releases</a></li>
          <li id="nav_update_website"><a href="/website_updates">Website Updates</a></li>
          <hr>
          <li><a href="https://issues.apache.org/jira/browse/PIRK ">Issue Tracker/JIRA <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://builds.apache.org/job/pirk/">Jenkins Builds <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://travis-ci.org/apache/incubator-pirk">Travis CI Builds <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://github.com/apache/incubator-pirk"> Pirk Github Mirror <i class="fa fa-external-link"></i></a></li>
        </ul>
        </li>
        <li class="nav-link"><a href="/roadmap">Roadmap</a></li>
       <ul class="nav navbar-nav navbar-right">
        <li class="dropdown">
        <a class="dropdown-toggle" data-toggle="dropdown" href="#">Apache Software Foundation<span class="caret"></span></a>
        <ul class="dropdown-menu">
          <li><a href="https://www.apache.org">Apache Homepage <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://www.apache.org/licenses/LICENSE-2.0">License <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://www.apache.org/foundation/sponsorship">Sponsorship <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://www.apache.org/security">Security <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://www.apache.org/foundation/thanks">Thanks <i class="fa fa-external-link"></i></a></li>
          <li><a href="https://www.apache.org/foundation/policies/conduct">Code of Conduct <i class="fa fa-external-link"></i></a></li>
        </ul>
        </li>
        </ul>
        </ul>
    </div> 
  </div>  
</nav>


  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div id="content">
          
          <h1 class="title">Making a Release</h1>
          
          <p>This is a guide to making a release of Apache Pirk (incubating). Please follow the steps below.</p>

<ol>
  <li><a href="#preliminaries">Preliminaries</a>
    <ul>
      <li><a href="#apache-release-documentation">Apache Release Documentation</a></li>
      <li><a href="#code-signing-key">Code Signing Key</a></li>
      <li><a href="#prepare-your-maven-settings">Prepare Your Maven Settings</a></li>
      <li><a href="#ensure-jira-issues-are-appropriately-tagged-for-the-release">Ensure JIRA Issues are Appropriately Tagged for the Release</a></li>
    </ul>
  </li>
  <li><a href="#create-the-release-candidate">Create the Release Candidate</a>
    <ul>
      <li><a href="#create-the-candidate-release-branch">Create the Candidate Release Branch</a></li>
      <li><a href="#create-the-candidate-release-artifacts">Create the Candidate Release Artifacts</a></li>
      <li><a href="#validate-the-release-candidate">Validate the Release Candidate</a></li>
      <li><a href="#close-the-staging-repository">Close the Staging Repository</a></li>
      <li><a href="#copy-artifacts-to-the-apache-distribution-dev-repository">Copy Artifacts to the Apache Distribution Dev Repository</a></li>
      <li><a href="#how-to-roll-back-a-release-candidate">How to Roll Back a Release Candidate</a></li>
      <li><a href="#generate-the-release-notes">Generate the Release Notes</a></li>
    </ul>
  </li>
  <li><a href="#vote-on-the-release">Vote on the Release</a>
    <ul>
      <li><a href="#apache-pirk-community-vote">Apache Pirk Community Vote</a></li>
      <li><a href="#incubator-pmc-vote">Incubator PMC Vote</a></li>
    </ul>
  </li>
  <li><a href="#publish-the-release">Publish the Release</a>
    <ul>
      <li><a href="#publish-the-maven-artifacts">Publish the Maven Artifacts</a></li>
      <li><a href="#publish-the-artifacts-to-the-apache-release-repository">Publish the Artifacts to the Apache Release Repository</a></li>
    </ul>
  </li>
  <li><a href="#announce-the-release">Announce the Release</a></li>
  <li><a href="#update-the-website">Update the Website</a></li>
</ol>

<h2 id="preliminaries">Preliminaries</h2>

<h3 id="apache-release-documentation">Apache Release Documentation</h3>

<p>The ASF release documentation, including the incubator release documentation, can be found here:</p>

<ul>
  <li><a href="http://www.apache.org/dev/release-publishing">Apache Release Guide</a></li>
  <li><a href="http://www.apache.org/dev/release.html">Apache Release Policy</a></li>
  <li><a href="http://incubator.apache.org/guides/releasemanagement.html">Apache Incubator Release Guidelines</a></li>
  <li><a href="http://incubator.apache.org/incubation/Incubation_Policy.html#Releases">Apache Incubator Release Policy</a></li>
  <li><a href="http://www.apache.org/dev/publishing-maven-artifacts.html">Maven Release Info</a></li>
</ul>

<h3 id="code-signing-key">Code Signing Key</h3>

<p>Create a code signing gpg key for release signing; use <code class="highlighter-rouge">&lt;your Apache ID&gt;@apache.org</code> for your primary ID for the code signing key. See the <a href="https://www.apache.org/dev/release-signing">Apache Release Signing documentation</a> for futher information.</p>

<ul>
  <li>Add your code signing key to your Apache ID <a href="https://id.apache.org/">here</a></li>
  <li>Publish it to a <a href="http://www.apache.org/dev/release-signing.html#keyserver">public key server</a> such as the <a href="http://pgp.mit.edu/">MIT key server</a>.</li>
  <li>Add it to the Pirk <a href="https://github.com/apache/incubator-pirk/blob/master/KEYS">KEYS file</a>.</li>
</ul>

<h3 id="prepare-your-maven-settings">Prepare Your Maven Settings</h3>

<p>Make sure that your Maven settings.xml file contains the following:</p>

<div class="highlighter-rouge"><pre class="highlight"><code>&lt;settings&gt;
   &lt;profiles&gt;
         &lt;profile&gt;
           &lt;id&gt;signed_release&lt;/id&gt;
           &lt;properties&gt;
               &lt;mavenExecutorId&gt;forked-path&lt;/mavenExecutorId&gt;
               &lt;gpg.keyname&gt;yourKeyName&lt;/gpg.keyname&gt;
               &lt;gpg.passphrase&gt;yourKeyPassword&lt;/gpg.passphrase&gt;
               &lt;deploy.altRepository&gt;incubator-pirk.releases::default::https://dist.apache.org/repos/dist/dev/incubator/pirk/&lt;/deploy.altRepository&gt;
           &lt;username&gt;yourApacheID&lt;/username&gt;
           &lt;deploy.url&gt;https://dist.apache.org/repos/dist/dev/incubator/pirk/&lt;/deploy.url&gt;
           &lt;/properties&gt;
       &lt;/profile&gt;
 &lt;/profiles&gt;
  &lt;servers&gt;
    	&lt;server&gt;
      		&lt;id&gt;apache.releases.https&lt;/id&gt;
      		&lt;username&gt;yourApacheID&lt;/username&gt;
     		&lt;password&gt;yourApachePassword&lt;/password&gt;
   		 &lt;/server&gt;
         &lt;server&gt;
             &lt;id&gt;repository.apache.org&lt;/id&gt;
             &lt;username&gt;yourApacheID&lt;/username&gt;
             &lt;password&gt;yourApachePassword&lt;/password&gt;
         &lt;/server&gt;
  &lt;/servers&gt;
&lt;/settings&gt;
</code></pre>
</div>

<h3 id="ensure-jira-issues-are-appropriately-tagged-for-the-release">Ensure JIRA Issues are Appropriately Tagged for the Release</h3>

<p>Ensure that all Pirk JIRA issues that are addressed in this release are marked with the release version in the ‘FixVersion’ field of the issue.</p>

<h2 id="create-the-release-candidate">Create the Release Candidate</h2>

<h3 id="create-the-candidate-release-branch">Create the Candidate Release Branch</h3>

<p>Create a branch off of master with its name equal to the release version. For example, if the candidate release version is 0.0.1, create a branch called 0.0.1.</p>

<h3 id="create-the-candidate-release-artifacts">Create the Candidate Release Artifacts</h3>

<p>Check out the candidate release branch.</p>

<p>Ensure that the application builds and all in-memory tests pass via <code class="highlighter-rouge">mvn clean install</code>.</p>

<p>Perform the following to generate and stage the artifacts:</p>

<ol>
  <li><code class="highlighter-rouge">mvn clean release:clean</code></li>
  <li><code class="highlighter-rouge">mvn release:prepare -Psigned_release -Darguments="-DskipTests"</code>
    <ul>
      <li>You will be prompted to answer the following questions:</li>
      <li>What is the release version for “Apache Pirk (incubating) Project”? <em>Answer:</em> <code class="highlighter-rouge">&lt;new release version&gt;-incubating</code></li>
      <li>What is SCM release tag or label for “Apache Pirk (incubating) Project”? <em>Answer:</em> Accept the default</li>
      <li>What is the new development version for “Apache Pirk (incubating) Project”? <em>Answer:</em> Accept the default</li>
    </ul>
  </li>
  <li><code class="highlighter-rouge">mvn -Psigned_release release:perform -Darguments="-DskipTests"</code>
    <ul>
      <li>This command will generate the artifacts and push them to the <a href="https://repository.apache.org/#stagingRepositories">Nexus repo</a>. If you would like to perform a dry run first (without pushing the artifacts to the repo), add the arg <code class="highlighter-rouge">-DdryRun=true</code></li>
    </ul>
  </li>
</ol>

<p>The candidate release artifacts can be found in the <a href="https://repository.apache.org/#stagingRepositories">Nexus staging repo</a>. Log in with your Apache creds; the candidate release artifacts are found in <code class="highlighter-rouge">orgapachepirk-1001</code> (the appended number may be different).</p>

<p>The candidate artifacts can also be found in the <code class="highlighter-rouge">target</code> folder of your local branch.</p>

<p>NOTE: If you are performing a source-only release, please remove all artifacts from the staging repo except for the .zip file containing the source and the javadocs jar file. In the Nexus GUI, you can right click on each artifact to be deleted and then select ‘Delete’.</p>

<h3 id="validate-the-release-candidate">Validate the Release Candidate</h3>

<p>As per the Apache documentation, verify that the release candidate artifacts satisfy the following:</p>

<ul>
  <li>Checksums and PGP signatures are valid</li>
  <li>Build is successful including automated tests</li>
  <li>DISCLAIMER is correct, filenames include “incubating”</li>
  <li>LICENSE and NOTICE files are correct and dependency licenses are acceptable
    <ul>
      <li>LICENSE and NOTICE files at the root of the artifact directory must only reflect the contents of the artifact in which they are contained.</li>
      <li>NOTE:
        <ul>
          <li>The LICENSE and NOTICE files contained at the root of the Apache Pirk code repository correspond to the source code only.</li>
          <li>License and notice files corresponding to the binary distribution/artifacts of Apache Pirk are found in the <code class="highlighter-rouge">src/main/resources/META-INF/bin-license-notice</code> directory under <code class="highlighter-rouge">LICENSE-bin</code> and <code class="highlighter-rouge">NOTICE-bin</code>. The full licenses of third-party dependencies contained in Pirk’s binary artifacts are located in the  <code class="highlighter-rouge">licenses</code> directory.</li>
        </ul>
      </li>
      <li>See:
        <ul>
          <li><a href="http://www.apache.org/dev/release.html#license">LICENSE file requirements</a></li>
          <li><a href="http://www.apache.org/dev/release.html#distributing-code-under-several-licenses">LICENSE requirements for distribution artifacts with multiple licenses</a></li>
          <li><a href="http://www.apache.org/dev/release.html#notice-content">NOTICE file requirements</a></li>
          <li><a href="http://apache.org/legal/">Apache Legal</a></li>
          <li><a href="http://www.apache.org/legal/resolved.html#category-a">Acceptable</a> and <a href="http://www.apache.org/legal/resolved.html#category-x">Unacceptable</a> Dependency Licenses</li>
        </ul>
      </li>
    </ul>
  </li>
  <li>The Cryptographic Export Control section in the README is up-to-date</li>
  <li>All source files have license headers where appropriate, RAT checks pass</li>
  <li>Javadocs have been generated correctly and are accurate</li>
  <li>The provenance of all source files is clear (ASF or software grants)</li>
</ul>

<h3 id="close-the-staging-repository">Close the Staging Repository</h3>

<p>If the release candidate appears to pass the validation checklist, close the staging repository in Nexus by selecting the staging repository <code class="highlighter-rouge">orgapachepirk-1001</code> and clicking on the ‘Close’ icon.</p>

<p>Nexus will now run through a series of checksum and signature validations.</p>

<p><em>If the checks pass</em>, Nexus will close the repository and give a URL to the closed staging repo (which contains the candidate artifacts). Include this URL in the voting email so that folks can find the staged candidate release artifacts. Move on to <a href="#copy-artifacts-to-the-apache-distribution-dev-repository">copy the artifacts via svn to the Apache distribution dev repository</a>.</p>

<p><em>If the checks do not pass</em>, follow the instructions on how to <a href="#how-to-roll-back-a-release-candidate">roll back the release candidate</a>, fix the issues, and start over with <a href="#create-the-candidate-release-artifacts">creating the candidate artifacts</a>.</p>

<h3 id="copy-artifacts-to-the-apache-distribution-dev-repository">Copy Artifacts to the Apache Distribution Dev-Repository</h3>

<p>Via svn, copy the candidate release artifacts to <a href="https://dist.apache.org/repos/dist/dev/incubator/pirk/">https://dist.apache.org/repos/dist/dev/incubator/pirk/</a></p>

<div class="highlighter-rouge"><pre class="highlight"><code>svn checkout https://dist.apache.org/repos/dist/dev/incubator/pirk/ --username=&lt;your user name&gt;

mkdir pirk/&lt;release version&gt;

copy the release artifacts into the new directory

svn add &lt;release version directory&gt;

svn commit -m 'adding candidate release artifacts' --username=&lt;your user name&gt;
</code></pre>
</div>

<h3 id="how-to-roll-back-a-release-candidate">How to Roll Back a Release Candidate</h3>

<p>A release candidate must be rolled back in Nexus, the Apache dist/dev repo, and locally.</p>

<p>To roll back the release candidate in Nexus, drop the staging repo by clicking the ‘Drop’ icon.</p>

<p>To roll back the release candidate in <a href="https://dist.apache.org/repos/dist/dev/incubator/pirk/">https://dist.apache.org/repos/dist/dev/incubator/pirk/</a>:</p>

<div class="highlighter-rouge"><pre class="highlight"><code>svn checkout https://dist.apache.org/repos/dist/dev/incubator/pirk/&lt;release version&gt; --username=&lt;your user name&gt;

svn delete &lt;release version directory&gt;

svn commit -m 'delete candidate release artifacts' --username=&lt;your user name&gt;
</code></pre>
</div>

<p>To roll back the release locally in your candidate release branch:</p>

<ol>
  <li><code class="highlighter-rouge">mvn -Psigned_release versions:set -DnewVersion=&lt;previous release version&gt;-Snapshot</code></li>
  <li><code class="highlighter-rouge">mvn -Psigned_release versions:commit</code></li>
  <li><code class="highlighter-rouge">git commit</code> to commit the new pom version</li>
  <li><code class="highlighter-rouge">git push --delete apache &lt;tagname&gt;</code> to delete the remote github tag</li>
  <li><code class="highlighter-rouge">git tag -d &lt;tagname&gt;</code> to deletes the local tag</li>
</ol>

<h3 id="generate-the-release-notes">Generate the Release Notes</h3>

<p>To generate the release notes within via <a href="https://issues.apache.org/jira/browse/PIRK">Pirk JIRA</a>, follow the instructions found <a href="https://confluence.atlassian.com/jira061/jira-administrator-s-guide/project-management/managing-versions/creating-release-notes">here</a>.</p>

<p>Include the link to the release notes in the voting emails.</p>

<h2 id="vote-on-the-release">Vote on the Release</h2>

<p>As per the Apache Incubator <a href="http://incubator.apache.org/incubation/Incubation_Policy.html#Releases">release guidelines</a>, all releases for incubating projects must go through a two-step voting process. <a href="#apache-pirk-community-vote">First</a>, release voting must successfully pass within the Apache Pirk community via the <code class="highlighter-rouge">dev@pirk.incubator.apache.org</code> mailing list. <a href="#incubator-pmc-vote">Then</a>, release voting must successfully pass within the Apache Incubator PMC via the <code class="highlighter-rouge">general@incubator.apache.org</code> mailing list.</p>

<p>General information regarding the Apache voting process can be found <a href="http://www.apache.org/foundation/voting.html">here</a>.</p>

<h3 id="apache-pirk-community-vote">Apache Pirk Community Vote</h3>

<p>To vote on a candidate release, send an email to the <a href="&#109;&#097;&#105;&#108;&#116;&#111;:&#100;&#101;&#118;&#064;&#112;&#105;&#114;&#107;&#046;&#097;&#112;&#097;&#099;&#104;&#101;&#046;&#105;&#110;&#099;&#117;&#098;&#097;&#116;&#111;&#114;&#046;&#111;&#114;&#103;">dev list</a> with subject <code class="highlighter-rouge">[VOTE]: Apache Pirk &lt;release version&gt; Release</code> and a body along the lines of:</p>

<div class="highlighter-rouge"><pre class="highlight"><code>This is the vote for &lt;release version&gt; of Apache Pirk (incubating).

The vote will run for at least 72 hours and will close on &lt;closing date&gt;.

The artifacts can be downloaded here: https://dist.apache.org/repos/dist/dev/incubator/pirk/release/&lt;release number&gt; or from the Maven staging repo here: https://repository.apache.org/content/repositories/&lt;repository name&gt;

All JIRAs completed for this release are tagged with 'FixVersion = &lt;release version&gt;'. You can view them here: &lt;insert link to the JIRA release notes&gt;

The artifacts have been signed with Key : &lt;ID of signing key&gt;

Please vote accordingly:

[ ] +1, accept RC as the official &lt;release version&gt; release 
[ ] -1, do not accept RC as the official &lt;release version&gt; release because...
</code></pre>
</div>

<p>If any -1 (binding) votes are entered, then address them such that the voter changes their vote to a +1 (binding) or cancel the vote, <a href="#how-to-roll-back-a-release-candidate">roll back the release candidate</a>, fix the issues, and start over with <a href="#create-the-candidate-release-artifacts">creating the candidate artifacts</a>.</p>

<p>Once 72 hours has passed (which is generally preferred) and/or at least three +1 (binding) votes have been cast with no -1 (binding) votes, send an email closing the vote and pronouncing the release candidate a success. Please use the subject: <code class="highlighter-rouge">[RESULT][VOTE]: Apache Pirk &lt;release version&gt; Release</code>.</p>

<div class="highlighter-rouge"><pre class="highlight"><code>The Apache Pirk &lt;release version&gt; vote is now closed and has passed as follows:

[number] +1 (binding) votes
[number] -1 (binding) votes

A vote Apache Pirk &lt;release version&gt; will now be called on general@incubator.apache.org.
</code></pre>
</div>

<h3 id="incubator-pmc-vote">Incubator PMC Vote</h3>

<p>Once the candidate release vote passes on dev@pirk.apache.incubator.org, call a vote on IMPC <code class="highlighter-rouge">general@incubator.apache.org</code> with an email a with subject <code class="highlighter-rouge">[VOTE]: Apache Pirk &lt;release version&gt; Release</code> and a body along the lines of:</p>

<div class="highlighter-rouge"><pre class="highlight"><code>The PPMC vote for the Apache Pirk 0.1.0-incubating release has passed. We kindly request that the IPMC now vote on the release.

The PPMC vote thread is located here: &lt;link to the dev voting thread&gt;

The artifacts can be downloaded here: https://dist.apache.org/repos/dist/dev/incubator/pirk/release/&lt;release number&gt; 

The artifacts have been signed with Key : &lt;ID of signing key&gt;

All JIRAs completed for this release are tagged with 'FixVersion = &lt;release version&gt;'. You can view them here: &lt;insert link to the JIRA release notes&gt;

Please vote accordingly:

[ ] +1, accept as the official Apache Pirk &lt;release number&gt; release 
[ ] -1, do not accept as the official Apache Pirk &lt;release number&gt; release because...

The vote will run for at least 72 hours.
</code></pre>
</div>

<p>If any -1 (binding) votes are entered, then address them such that the voter changes their vote to a +1 (binding) or cancel the vote, <a href="#how-to-roll-back-a-release-candidate">roll back the release candidate</a>, fix the issues, and start over with <a href="#create-the-candidate-release-artifacts">creating the candidate artifacts</a> (including re-voting within the Apache Pirk community on dev@pirk.apache.incubator.org).</p>

<p>Once 72 hours has passed (which is generally preferred) and/or at least three +1 (binding) votes have been cast with no -1 (binding) votes, send an email closing the vote and pronouncing the release candidate a success. Please use the subject: <code class="highlighter-rouge">[RESULT][VOTE]: Apache Pirk &lt;release version&gt; Release</code></p>

<div class="highlighter-rouge"><pre class="highlight"><code>The Apache Pirk &lt;release version&gt; vote is now closed and has passed as follows:

[number] +1 (binding) votes
[number] -1 (binding) votes

The Apache Pirk (incubating) community will proceed with the release.
</code></pre>
</div>

<h2 id="publish-the-release">Publish the Release</h2>

<p>Once the Apache Pirk PPMC and IPMC votes both pass, publish the release artifacts to the <a href="#publish-the-maven-artifacts">Nexus Maven repository</a> and to the <a href="#publish-the-artifacts-to-the-apache-release-repository">Apache release repository</a>.</p>

<h3 id="publish-the-maven-artifacts">Publish the Maven Artifacts</h3>

<p>Release the Maven artifacts in Nexus by selecting the staging repository <code class="highlighter-rouge">orgapachepirk-1001</code> and clicking on the ‘Release’ icon.</p>

<h3 id="publish-the-artifacts-to-the-apache-release-repository">Publish the Artifacts to the Apache Release Repository</h3>

<p>Via svn, copy the candidate release artifacts to <a href="https://dist.apache.org/repos/dist/release/incubator/pirk/">https://dist.apache.org/repos/dist/release/incubator/pirk/</a></p>

<div class="highlighter-rouge"><pre class="highlight"><code>svn checkout https://dist.apache.org/repos/dist/release/incubator/pirk/ --username=&lt;your user name&gt;

mkdir pirk/&lt;release version&gt;

copy the release artifacts into the new directory

svn add &lt;release version directory&gt;

svn commit -m 'adding release artifacts' --username=&lt;your user name&gt; 
</code></pre>
</div>

<h2 id="announce-the-release">Announce the Release</h2>

<p>Send an email to <code class="highlighter-rouge">announce@apache.org</code>, <code class="highlighter-rouge">general@incubator.apache.org</code>, and <code class="highlighter-rouge">dev@pirk.apache.incubator.org</code> with the subject <code class="highlighter-rouge">[ANNOUNCE] Apache Pirk &lt;release number&gt; Release</code> and a body along the lines of:</p>

<div class="highlighter-rouge"><pre class="highlight"><code>The Apache Pirk team would like to announce the release of Apache Pirk &lt;release version&gt;. 

Apache Pirk (incubating) is a framework for scalable Private Information Retrieval (PIR). The goal of Pirk is to provide a landing place for robust, scalable, and practical implementations of PIR algorithms.

More details regarding Apache Pirk can be found here:
http://pirk.incubator.apache.org/

The release artifacts can be downloaded here: 
https://dist.apache.org/repos/dist/release/incubator/pirk/&lt;release version&gt;

Maven artifacts have been made available here: 
https://repository.apache.org/content/repositories/releases/org/apache/pirk/

All JIRAs completed for this release are tagged with 'FixVersion = &lt;release version&gt;'; the release notes can be found here: 
&lt;link to release notes on JIRA&gt;

Thanks!

The Apache Pirk Team

--- DISCLAIMER  Apache Pirk is an effort undergoing incubation at the Apache Software Foundation (ASF), sponsored by the Apache Incubator PMC. Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects.  While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.
</code></pre>
</div>

<p>General Apache information regarding announcing a release may be found <a href="http://www.apache.org/dev/release.html#release-announcements">here</a>.</p>

<h2 id="update-the-website">Update the Website</h2>

<p>Add the current release link to the <a href="/downloads">Downloads page</a>.</p>

<p>Update the <a href="/javadocs">javadocs</a>.</p>

<p>Update the <a href="/news">News</a> page and the News info bar on the left side of the <a href="/">homepage</a> (via editing _includes/newsfeed.md) with the release information.</p>


        </div>

        
<footer>

  <p><a href="https://www.apache.org"><img src="/images/feather-small.gif" alt="Apache Software Foundation" id="asf-logo" height="100" /></a></p>

  <p>Copyright © 2016-2016 The Apache Software Foundation. Licensed under the <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>.</p>

</footer>


      </div>
    </div>
  </div>
</body>
</html>
