HBase 1.x requires Java 7 to build. See Table 2.1, “Java” for Java requirements per HBase release.
HBase 0.96.x will run on Hadoop 1.x or Hadoop 2.x. HBase 0.98 still runs on both, but HBase 0.98 deprecates use of Hadoop 1. HBase 1.x will not run on Hadoop 1. In the following procedures, we make a distinction between HBase 1.x builds and the awkward process involved building HBase 0.96/0.98 for either Hadoop 1 or Hadoop 2 targets.
You must choose which Hadoop to build against. It is not possible to build a single HBase binary that runs against both Hadoop 1 and Hadoop 2. Hadoop is included in the build, because it is needed to run HBase in standalone mode. Therefore, the set of modules included in the tarball changes, depending on the build target. To determine which HBase you have, look at the HBase version. The Hadoop version is embedded within it.
Maven, our build system, natively does not allow a single product to be built
against different dependencies. Also, Maven cannot change the set of included
modules and write out the correct
pom.xml files with
appropriate dependencies, even using two build targets, one for Hadoop 1 and another
for Hadoop 2. A prerequisite step is required, which takes as input the current
pom.xmls and generates Hadoop 1 or Hadoop 2 versions using
a script in the
dev-tools/ directory, called
X is either
2. You then reference these generated poms when you build.
For now, just be aware of the difference between HBase 1.x builds and those of HBase
0.96-0.98. This difference is important to the build instructions.
Example 18.2. Example
Publishing to maven requires you sign the artifacts you want to upload. For
the build to sign them for you, you a properly configured
settings.xml in your local repository under
.m2, such as the following.
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd"> <servers> <!- To publish a snapshot of some part of Maven --> <server> <id>apache.snapshots.https</id> <username>YOUR_APACHE_ID </username> <password>YOUR_APACHE_PASSWORD </password> </server> <!-- To publish a website using Maven --> <!-- To stage a release of some part of Maven --> <server> <id>apache.releases.https</id> <username>YOUR_APACHE_ID </username> <password>YOUR_APACHE_PASSWORD </password> </server> </servers> <profiles> <profile> <id>apache-release</id> <properties> <gpg.keyname>YOUR_KEYNAME</gpg.keyname> <!--Keyname is something like this ... 00A5F21E... do gpg --list-keys to find it--> <gpg.passphrase>YOUR_KEY_PASSWORD </gpg.passphrase> </properties> </profile> </profiles> </settings>
These instructions are for building HBase 1.0.x. For building earlier versions, the process is different. See this section under the respective release documentation folders.
Point Releases. If you are making a point release (for example to quickly address a critical incompatability or security problem) off of a release branch instead of a development branch, the tagging instructions are slightly different. I'll prefix those special steps with Point Release Only.
Before You Begin. Before you make a release candidate, do a practice run by deploying a
snapshot. Before you start, check to be sure recent builds have been passing for
the branch from where you are going to take your release. You should also have
tried recent branch tips out on a cluster under load, perhaps by running the
hbase-it integration test suite for a few hours to 'burn in'
the near-candidate bits.
At this point you should tag the previous release branch (ex: 0.96.1) with the new point release tag (e.g. 0.96.1.1 tag). Any commits with changes for the point release should be appled to the new tag.
The Hadoop How To Release wiki page is used as a model for most of the instructions below, and may have more detail on particular sections, so it is worth review.
On OSX, you may need to specify the heap space for Maven commands, by setting
MAVEN_OPTS variable to
-Xmx3g. You can
prefix the variable to the Maven command, as in the following example:
MAVEN_OPTS="-Xmx2g" mvn package
You could also set this in an environment variable or alias in your shell.
Procedure 18.2. Release Procedure
dev-support/make_rc.sh automates many of these
steps. It does not do the modification of the
for the release, the close of the staging repository in Apache Maven (human
intervention is needed here), the checking of the produced artifacts to ensure
they are 'good' -- e.g. extracting the produced tarballs, verifying that they
look right, then starting HBase and checking that everything is running
correctly, then the signing and pushing of the tarballs to people.apache.org. The script
handles everything else, and comes in handy.
CHANGES.txt file and the POM files.
CHANGES.txt with the changes since the last
release. Make sure the URL to the JIRA points to the proper location which
lists fixes for this release. Adjust the version in all the POM files
appropriately. If you are making a release candidate, you must remove the
-SNAPSHOT label from all versions. If you are running
this receipe to publish a snapshot, you must keep the
-SNAPSHOT suffix on the hbase version. The Versions
Maven Plugin can be of use here. To set a version in all the many
poms of the hbase multi-module project, use a command like the
$ mvn clean org.codehaus.mojo:versions-maven-plugin:1.3.1:set -DnewVersion=0.96.0
CHANGES.txt and any version
Update the documentation.
Update the documentation under
usually involves copying the latest from trunk and making version-particular
adjustments to suit this release candidate version.
Build the source tarball.
Now, build the source tarball. This tarball is Hadoop-version-independent.
It is just the pure source code and documentation without a particular
hadoop taint, etc. Add the
-Prelease profile when
building. It checks files for licenses and will fail the build if unlicensed
files are present.
$ mvn clean install -DskipTests assembly:single -Dassembly.file=hbase-assembly/src/main/assembly/src.xml -Prelease
Extract the tarball and make sure it looks good. A good test for the src
tarball being 'complete' is to see if you can build new tarballs from this
source bundle. If the source tarball is good, save it off to a
version directory, a directory somewhere where you
are collecting all of the tarballs you will publish as part of the release
candidate. For example if you were building a hbase-0.96.0 release
candidate, you might call the directory
hbase-0.96.0RC0. Later you will publish this directory
as our release candidate up on people.apache.org/
Build the binary tarball.
Next, build the binary tarball. Add the
profile when building. It checks files for licenses and will fail the build
if unlicensed files are present. Do it in two steps.
First install into the local repository
$ mvn clean install -DskipTests -Prelease
Next, generate documentation and assemble the tarball.
$ mvn install -DskipTests site assembly:single -Prelease
Otherwise, the build complains that hbase modules are not in the maven repository when you try to do it at once, especially on fresh repository. It seems that you need the install goal in both steps.
Extract the generated tarball and check it out. Look at the documentation, see if it runs, etc. If good, copy the tarball to the above mentioned version directory.
Create a new tag.
The following step that creates a new tag can be skipped since you've already created the point release tag
Tag the release at this point since it looks good. If you find an issue later, you can delete the tag and start over. Release needs to be tagged for the next step.
Deploy to the Maven Repository.
Next, deploy HBase to the Apache Maven repository, using the
apache-release profile instead of the
release profile when running the mvn
deploy command. This profile invokes the Apache pom referenced
by our pom files, and also signs your artifacts published to Maven, as long
settings.xml is configured correctly, as
described in Example 18.2, “Example
$ mvn deploy -DskipTests -Papache-release
This command copies all artifacts up to a temporary staging Apache mvn repository in an 'open' state. More work needs to be done on these maven artifacts to make them generally available.
Make the Release Candidate available.
The artifacts are in the maven repository in the staging area in the
'open' state. While in this 'open' state you can check out what you've
published to make sure all is good. To do this, login at repository.apache.org
using your Apache ID. Find your artifacts in the staging repository. Browse
the content. Make sure all artifacts made it up and that the poms look
generally good. If it checks out, 'close' the repo. This will make the
artifacts publically available. You will receive an email with the URL to
give out for the temporary staging repository for others to use trying out
this new release candidate. Include it in the email that announces the
release candidate. Folks will need to add this repo URL to their local poms
or to their local
settings.xml file to pull the
published release candidate artifacts. If the published artifacts are
incomplete or have problems, just delete the 'open' staged artifacts.
See the hbase-downstreamer test for a simple example of a project
that is downstream of HBase an depends on it. Check it out and run its
simple test to make sure maven artifacts are properly deployed to the
maven repository. Be sure to edit the pom to point to the proper staging
repository. Make sure you are pulling from the repository when tests run
and that you are not getting from your local repository, by either
-U flag or deleting your local repo content and
check maven is pulling from remote out of the staging repository.
See Publishing Maven Artifacts for some pointers on this maven staging process.
We no longer publish using the maven release plugin. Instead we do mvn deploy. It seems to give us a backdoor to maven release publishing. If there is no -SNAPSHOT on the version string, then we are 'deployed' to the apache maven repository staging directory from which we can publish URLs for candidates and later, if they pass, publish as release (if a -SNAPSHOT on the version string, deploy will put the artifacts up into apache snapshot repos).
If the HBase version ends in
-SNAPSHOT, the artifacts
go elsewhere. They are put into the Apache snapshots repository directly and
are immediately available. Making a SNAPSHOT release, this is what you want
If you used the
make_rc.sh script instead of doing
the above manually, do your sanity checks now.
At this stage, you have two tarballs in your 'version directory' and a
set of artifacts in a staging area of the maven repository, in the 'closed'
state. These are publicly accessible in a temporary staging repository whose
URL you should have gotten in an email. The above mentioned script,
make_rc.sh does all of the above for you minus the
check of the artifacts built, the closing of the staging repository up in
maven, and the tagging of the release. If you run the script, do your checks
at this stage verifying the src and bin tarballs and checking what is up in
staging using hbase-downstreamer project. Tag before you start the build.
You can always delete it if the build goes haywire.
Sign and upload your version directory to people.apache.org.
If all checks out, next put the version directory up on people.apache.org. You will need to sign and fingerprint them before you push them up. In the version directory run the following commands:
$ for i in *.tar.gz; do echo $i; gpg --print-mds $i > $i.mds ; done $ for i in *.tar.gz; do echo $i; gpg --armor --output $i.asc --detach-sig $i ; done $ cd .. # Presuming our 'version directory' is named 0.96.0RC0, now copy it up to people.apache.org. $ rsync -av 0.96.0RC0 people.apache.org:public_html
Make sure the people.apache.org directory is showing and that the mvn repo URLs are good. Announce the release candidate on the mailing list and call a vote.
Make sure your
settings.xml is set up properly, as in Example 18.2, “Example
~/.m2/settings.xml File”. Make sure the hbase version includes
-SNAPSHOT as a suffix. Following is an example of publishing
SNAPSHOTS of a release that had an hbase version of 0.96.0 in its poms.
$ mvn clean install -DskipTests javadoc:aggregate site assembly:single -Prelease $ mvn -DskipTests deploy -Papache-release
make_rc.sh script mentioned above (see Section 18.5.2, “Making a Release Candidate”) can help you publish
Make sure your
hbase.version has a
suffix before running the script. It will put a snapshot up into the apache snapshot
repository for you.