kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jdcry...@apache.org
Subject [08/45] incubator-kudu git commit: Update docs for 0.9.1
Date Fri, 01 Jul 2016 00:13:12 GMT
http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/6e3145f8/releases/0.9.1/docs/contributing.html
----------------------------------------------------------------------
diff --git a/releases/0.9.1/docs/contributing.html b/releases/0.9.1/docs/contributing.html
new file mode 100644
index 0000000..5bc5094
--- /dev/null
+++ b/releases/0.9.1/docs/contributing.html
@@ -0,0 +1,640 @@
+---
+title: Contributing to Apache Kudu (incubating)
+layout: default
+active_nav: docs
+last_updated: 'Last updated 2016-06-29 16:16:41 PDT'
+---
+<!--
+
+Licensed 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.
+-->
+
+
+<div class="container">
+  <div class="row">
+    <div class="col-md-9">
+
+<h1>Contributing to Apache Kudu (incubating)</h1>
+      <div class="sect1">
+<h2 id="_contributing_patches_using_gerrit"><a class="link" href="#_contributing_patches_using_gerrit">Contributing Patches Using Gerrit</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>The Kudu team uses Gerrit for code review, rather than Github pull requests. Typically,
+you pull from Github but push to Gerrit, and Gerrit is used to review code and merge
+it into Github.</p>
+</div>
+<div class="paragraph">
+<p>See the <a href="https://www.mediawiki.org/wiki/Gerrit/Tutorial">Gerrit Tutorial</a>
+for an overview of using Gerrit for code review.</p>
+</div>
+<div class="sect2">
+<h3 id="_initial_setup_for_gerrit"><a class="link" href="#_initial_setup_for_gerrit">Initial Setup for Gerrit</a></h3>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p>Sign in to <a href="http://gerrit.cloudera.org:8080">Gerrit</a> using your Github username.</p>
+</li>
+<li>
+<p>Go to <a href="http://gerrit.cloudera.org:8080/#/settings/">Settings</a>. Update your name
+and email address on the <strong>Contact Information</strong> page, and upload a SSH public key.
+If you do not update your name, it will show up as "Anonymous Coward" in Gerrit reviews.</p>
+</li>
+<li>
+<p>If you have not done so, clone the main Kudu repository. By default, the main remote
+is called <code>origin</code>. When you fetch or pull, you will do so from <code>origin</code>.</p>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code class="language-bash" data-lang="bash">git clone https://github.com/apache/incubator-kudu kudu</code></pre>
+</div>
+</div>
+</li>
+<li>
+<p>Change to the new <code>kudu</code> directory.</p>
+</li>
+<li>
+<p>Add a <code>gerrit</code> remote. In the following command, substitute &lt;username&gt; with your
+Github username.</p>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code class="language-bash" data-lang="bash">git remote add gerrit ssh://&lt;username&gt;@gerrit.cloudera.org:29418/kudu</code></pre>
+</div>
+</div>
+</li>
+<li>
+<p>Run the following command to install the
+Gerrit <code>commit-msg</code> hook. Use the following command, replacing <code>&lt;username&gt;</code> with your
+Github username.</p>
+<div class="listingblock">
+<div class="content">
+<pre>gitdir=$(git rev-parse --git-dir); scp -p -P 29418 &lt;username&gt;@gerrit.cloudera.org:hooks/commit-msg ${gitdir}/hooks/</pre>
+</div>
+</div>
+</li>
+<li>
+<p>Be sure you have set the Kudu repository to use <code>pull --rebase</code> by default. You
+can use the following two commands, assuming you have only ever checked out <code>master</code>
+so far:</p>
+<div class="listingblock">
+<div class="content">
+<pre>git config branch.autosetuprebase always
+git config branch.master.rebase true</pre>
+</div>
+</div>
+<div class="paragraph">
+<p>If for some reason you had already checked out branches other than <code>master</code>, substitute
+<code>master</code> for the other branch names in the second command above.</p>
+</div>
+</li>
+</ol>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_submitting_patches"><a class="link" href="#_submitting_patches">Submitting Patches</a></h3>
+<div class="paragraph">
+<p>To submit a patch, first commit your change (using a descriptive multi-line
+commit message if possible), then push the request to the <code>gerrit</code> remote. For instance, to push a change
+to the <code>master</code> branch:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre>git push gerrit HEAD:refs/for/master --no-thin</pre>
+</div>
+</div>
+<div class="paragraph">
+<p>or to push a change to the <code>gh-pages</code> branch (to update the website):</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre>git push gerrit HEAD:refs/for/gh-pages --no-thin</pre>
+</div>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-note" title="Note"></i>
+</td>
+<td class="content">
+The <code>--no-thin</code> argument is a workaround to prevent an error in Gerrit. See
+<a href="https://code.google.com/p/gerrit/issues/detail?id=1582" class="bare">https://code.google.com/p/gerrit/issues/detail?id=1582</a>.
+</td>
+</tr>
+</table>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-tip" title="Tip"></i>
+</td>
+<td class="content">
+Consider creating Git aliases for the above commands. Gerrit also includes
+a command-line tool called
+<a href="https://www.mediawiki.org/wiki/Gerrit/Tutorial#Installing_git-review">git-review</a>,
+which you may find helpful.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>Gerrit will add a change ID to your commit message and will create a Gerrit review,
+whose URL will be emitted as part of the push reply. If desired, you can send a message
+to the <code>kudu-dev</code> mailing list, explaining your patch and requesting review.</p>
+</div>
+<div class="paragraph">
+<p>After getting feedback, you can update or amend your commit, (for instance, using
+a command like <code>git commit --amend</code>) while leaving the Change
+ID intact. Push your change to Gerrit again, and this will create a new patch set
+in Gerrit and notify all reviewers about the change.</p>
+</div>
+<div class="paragraph">
+<p>When your code has been reviewed and is ready to be merged into the Kudu code base,
+a Kudu committer will merge it using Gerrit. You can discard your local branch.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_abandoning_a_review"><a class="link" href="#_abandoning_a_review">Abandoning a Review</a></h3>
+<div class="paragraph">
+<p>If your patch is not accepted or you decide to pull it from consideration, you can
+use the Gerrit UI to <strong>Abandon</strong> the patch. It will still show in Gerrit&#8217;s history,
+but will not be listed as a pending review.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_reviewing_patches_in_gerrit"><a class="link" href="#_reviewing_patches_in_gerrit">Reviewing Patches In Gerrit</a></h3>
+<div class="paragraph">
+<p>You can view a unified or side-by-side diff of changes in Gerrit using the web UI.
+To leave a comment, click the relevant line number or highlight the relevant part
+of the line, and type 'c' to bring up a comment box. To submit your comments and/or
+your review status, go up to the top level of the review and click <strong>Reply</strong>. You can
+add additional top-level comments here, and submit them.</p>
+</div>
+<div class="paragraph">
+<p>To check out code from a Gerrit review, click <strong>Download</strong> and paste the relevant Git
+commands into your Git client. You can then update the commit and push to Gerrit to
+submit a patch to the review, even if you were not the original reviewer.</p>
+</div>
+<div class="paragraph">
+<p>Gerrit allows you to vote on a review. A vote of <code>+2</code> from at least one committer
+(besides the submitter) is required before the patch can be merged.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_code_style"><a class="link" href="#_code_style">Code Style</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>Get familiar with these guidelines so that your contributions can be reviewed and
+integrated quickly and easily.</p>
+</div>
+<div class="paragraph">
+<p>In general, Kudu follows the
+<a href="https://google.github.io/styleguide/cppguide.html">Google C++ Style Guide</a>,
+with the following exceptions:</p>
+</div>
+<div class="sect2">
+<h3 id="_limitations_on_code_boost_code_library_use"><a class="link" href="#_limitations_on_code_boost_code_library_use">Limitations on <code>boost</code> Library Use</a></h3>
+<div class="paragraph">
+<p><code>boost</code> libraries can be used in cases where a suitable
+replacement does not exist in the Kudu code base. However, try to avoid introducing
+dependencies on new <code>boost</code> libraries, and use Kudu code in preference
+to <code>boost</code> where available. For example, do not use `boost&#8217;s scoped pointer
+implementations.</p>
+</div>
+<div class="ulist">
+<div class="title">Approved <code>boost</code> Libraries</div>
+<ul>
+<li>
+<p><code>boost::assign</code> (container literals)</p>
+</li>
+<li>
+<p><code>boost::shared_mutex</code> (but prefer Kudu&#8217;s spin lock implementation for short
+critical sections)</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>Check that any features from <code>boost</code> you use are present in <strong><code>boost</code> 1.46</strong>
+or earlier, for compatibility with RHEL 6.</p>
+</div>
+<div class="paragraph">
+<div class="title"><code>boost</code> Libraries and the Kudu C++ Client</div>
+<p>Do not use <code>boost</code> in any public headers for the Kudu C++ client, because
+<code>boost</code> commonly breaks backward compatibility, and passing data between two <code>boost</code>
+versions (one by the user, one by Kudu) causes serious issues.</p>
+</div>
+<div class="paragraph">
+<p>In addition, do not create dependencies from the Kudu C++ client to any <code>boost</code>
+libraries. <code>libboost_system</code> is particularly troublesome, as any <code>boost</code> code
+that throws exceptions will grow a dependency on it. Among other things, you
+cannot use <code>boost::{lock_guard,unique_lock,shared_lock}</code> in any code consumed
+by the C++ client (such as <em>common/</em> and <em>util/</em>).</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_line_length"><a class="link" href="#_line_length">Line length</a></h3>
+<div class="paragraph">
+<p>The Kudu team allows line lengths of 100 characters per line, rather than Google&#8217;s standard of 80. Try to
+keep under 80 where possible, but you can spill over to 100 or so if necessary.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_pointers"><a class="link" href="#_pointers">Pointers</a></h3>
+<div class="paragraph">
+<div class="title">Smart Pointers and Singly-Owned Pointers</div>
+<p>Generally, most objects should have clear "single-owner" semantics.
+Most of the time, singly-owned objects can be wrapped in a <code>gscoped_ptr&lt;&gt;</code>
+which ensures deletion on scope exit and prevents accidental copying.
+<code>gscoped_ptr</code> is similar to C++11&#8217;s <code>unique_ptr</code> in that it has a <code>release</code>
+method and also provides emulated <code>move</code> semantics (see <em>gscoped_ptr.h</em> for
+example usage).</p>
+</div>
+<div class="paragraph">
+<p>If an object is singly owned, but referenced from multiple places, such as when
+the pointed-to object is known to be valid at least as long as the pointer itself,
+associate a comment with the constructor which takes and stores the raw pointer,
+as in the following example.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code class="language-c++" data-lang="c++">  // 'blah' must remain valid for the lifetime of this class
+  MyClass(const Blah* blah) :
+    blah_(blah) {
+  }</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>If you use raw pointers within STL collections or inside of vectors and other containers,
+associate a comment with the container, which explains the ownership
+semantics (owned or un-owned). Use utility code from <em>gutil/stl_util.h</em>, such as
+<code>STLDeleteElements</code> or <code>ElementDeleter</code>, to ease handling of deletion of the
+contained elements.</p>
+</div>
+<div class="admonitionblock warning">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-warning" title="Warning"></i>
+</td>
+<td class="content">
+Using <code>std::auto_ptr</code> is strictly disallowed because of its difficult and
+bug-prone semantics.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<div class="title">Smart Pointers for Multiply-Owned Pointers:</div>
+<p>Although single ownership is ideal, sometimes it is not possible, particularly
+when multiple threads are in play and the lifetimes of the pointers are not
+clearly defined. In these cases, you can use either <code>std::tr1::shared_ptr</code> or
+Kudu&#8217;s own <code>scoped_refptr</code> from <em>gutil/ref_counted.hpp</em>. Each of these mechanisms
+relies on reference counting to automatically delete the referent once no more
+pointers remain. The key difference between these two types of pointers is that
+<code>scoped_refptr</code> requires that the object extend a <code>RefCounted</code> base class, and
+stores its reference count inside the object storage itself, while <code>shared_ptr</code>
+maintains a separate reference count on the heap.</p>
+</div>
+<div class="paragraph">
+<p>The pros and cons are:</p>
+</div>
+<div class="ulist none">
+<div class="title"><code>shared_ptr</code></div>
+<ul class="none">
+<li>
+<p><span class="icon green"><i class="fa fa-plus-circle"></i></span> can be used with any type of object, without the
+object deriving from a special base class</p>
+</li>
+<li>
+<p><span class="icon green"><i class="fa fa-plus-circle"></i></span> part of the standard library and familiar to most
+C++ developers</p>
+</li>
+<li>
+<p><span class="icon red"><i class="fa fa-minus-circle"></i></span> creating a new object requires two allocations instead
+of one (one to create the ref count, and one to create the object)</p>
+</li>
+<li>
+<p><span class="icon red"><i class="fa fa-minus-circle"></i></span> the ref count may not be near the object on the heap,
+so extra cache misses may be incurred on access</p>
+</li>
+<li>
+<p><span class="icon red"><i class="fa fa-minus-circle"></i></span> the <code>shared_ptr</code> instance itself requires 16 bytes
+(pointer to the ref count and pointer to the object)</p>
+</li>
+<li>
+<p><span class="icon red"><i class="fa fa-minus-circle"></i></span> if you convert from the <code>shared_ptr</code> to a raw pointer,
+you can&#8217;t get back the <code>shared_ptr</code></p>
+</li>
+</ul>
+</div>
+<div class="ulist none">
+<div class="title"><code>scoped_refptr</code></div>
+<ul class="none">
+<li>
+<p><span class="icon green"><i class="fa fa-plus-circle fa-pro"></i></span> only requires a single allocation, and ref count
+is on the same cache line as the object</p>
+</li>
+<li>
+<p><span class="icon green"><i class="fa fa-plus-circle fa-pro"></i></span> the pointer only requires 8 bytes (since
+the ref count is within the object)</p>
+</li>
+<li>
+<p><span class="icon green"><i class="fa fa-plus-circle fa-pro"></i></span> you can manually increase or decrease
+reference counts when more control is required</p>
+</li>
+<li>
+<p><span class="icon green"><i class="fa fa-plus-circle fa-pro"></i></span> you can convert from a raw pointer back
+to a <code>scoped_refptr</code> safely without worrying about double freeing</p>
+</li>
+<li>
+<p><span class="icon green"><i class="fa fa-plus-circle fa-pro"></i></span> since we control the implementation, we
+can implement features, such as debug builds that capture the stack trace of every
+referent to help debug leaks.</p>
+</li>
+<li>
+<p><span class="icon red"><i class="fa fa-minus-circle fa-con"></i></span> the referred-to object must inherit
+from <code>RefCounted</code></p>
+</li>
+<li>
+<p><span class="icon red"><i class="fa fa-minus-circle fa-con"></i></span> does not support <code>weak_ptr&lt;&gt;</code> use cases</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>Since <code>scoped_refptr</code> is generally faster and smaller, try to use it
+rather than <code>shared_ptr</code> in new code. Existing code uses <code>shared_ptr</code>
+in many places. When interfacing with that code, you can continue to use <code>shared_ptr</code>.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_function_binding_and_callbacks"><a class="link" href="#_function_binding_and_callbacks">Function Binding and Callbacks</a></h3>
+<div class="paragraph">
+<p>Existing code uses <code>boost::bind</code> and <code>boost::function</code> for function binding and
+callbacks. For new code, use the <code>Callback</code> and <code>Bind</code> classes in <code>gutil</code> instead.
+While less full-featured (<code>Bind</code> doesn&#8217;t support argument
+place holders, wrapped function pointers, or function objects), they provide
+more options by the way of argument lifecycle management. For example, a
+bound argument whose class extends <code>RefCounted</code> will be incremented during <code>Bind</code>
+and decremented when the <code>Callback</code> goes out of scope.</p>
+</div>
+<div class="paragraph">
+<p>See the large file comment in <em>gutil/callback.h</em> for more details, and
+<em>util/callback_bind-test.cc</em> for examples.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="__code_cmake_code_style_guide"><a class="link" href="#__code_cmake_code_style_guide"><code>CMake</code> Style Guide</a></h3>
+<div class="paragraph">
+<p><code>CMake</code> allows commands in lower, upper, or mixed case. To keep
+the CMake files consistent, please use the following guidelines:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p><strong>built-in commands</strong> in lowercase</p>
+</li>
+</ul>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre>add_subdirectory(some/path)</pre>
+</div>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p><strong>built-in arguments</strong> in uppercase</p>
+</li>
+</ul>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre>message(STATUS "message goes here")</pre>
+</div>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p><strong>custom commands or macros</strong> in uppercase</p>
+</li>
+</ul>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre>ADD_KUDU_TEST(some-test)</pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_gflags"><a class="link" href="#_gflags">GFlags</a></h3>
+<div class="paragraph">
+<p>Kudu uses gflags for both command-line and file-based configuration. Use these guidelines
+to add a new gflag. All new gflags must conform to these
+guidelines. Existing non-conformant ones will be made conformant in time.</p>
+</div>
+<div class="paragraph">
+<div class="title">Name</div>
+<p>The gflag&#8217;s name conveys a lot of information, so choose a good name. The name
+will propagate into other systems, such as the <a href="configuration_reference.html">Configuration
+Reference</a>.
+- The different parts of a multi-word name should be separated by underscores.
+  For example, <code>fs_data_dirs</code>.
+- The name should be prefixed with the context that it affects. For example,
+  <code>webserver_num_worker_threads</code> and <code>cfile_default_block_size</code>. Context can be
+  difficult to define, so bear in mind that this prefix will be
+  used to group similar gflags together. If the gflag affects the entire
+  process, it should not be prefixed.
+- If the gflag is for a quantity, the name should be suffixed with the units.
+  For example, <code>remote_bootstrap_idle_timeout_ms</code>.
+- Where possible, use short names. This will save time for those entering
+  command line options by hand.
+- The name is part of Kudu&#8217;s compatibility contract, and should not change
+  without very good reason.</p>
+</div>
+<div class="paragraph">
+<div class="title">Default value</div>
+<p>Choosing a default value is generally simple, but like the name, it propagates
+into other systems.
+- The default value is part of Kudu&#8217;s compatibility contract, and should not
+  change without very good reason.</p>
+</div>
+<div class="paragraph">
+<div class="title">Description</div>
+<p>The gflag&#8217;s description should supplement the name and provide additional
+context and information. Like the name, the description propagates into other
+systems.
+- The description may include multiple sentences. Each should begin with a
+  capital letter, end with a period, and begin one space after the previous.
+- The description should NOT include the gflag&#8217;s type or default value; they are
+  provided out-of-band.
+- The description should be in the third person. Do not use words like <code>you</code>.
+- A gflag description can be changed freely; it is not expected to remain the
+  same across Kudu releases.</p>
+</div>
+<div class="paragraph">
+<div class="title">Tags</div>
+<p>Kudu&#8217;s gflag tagging mechanism adds machine-readable context to each gflag, for
+use in consuming systems such as documentation or management tools. See the large block
+comment in <em>flag_tags.h</em> for guidelines.</p>
+</div>
+<div class="ulist">
+<div class="title">Miscellaneous</div>
+<ul>
+<li>
+<p>Avoid creating multiple gflags for the same logical parameter. For
+example, many Kudu binaries need to configure a WAL directory. Rather than
+creating <code>foo_wal_dir</code> and <code>bar_wal_dir</code> gflags, better to have a single
+<code>kudu_wal_dir</code> gflag for use universally.</p>
+</li>
+</ul>
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_testing"><a class="link" href="#_testing">Testing</a></h2>
+<div class="sectionbody">
+<div class="dlist">
+<dl>
+<dt class="hdlist1">All new code should have tests.</dt>
+<dd>
+<p>Add new tests either in existing files, or create new test files as necessary.</p>
+</dd>
+<dt class="hdlist1">All bug fixes should have tests.</dt>
+<dd>
+<p>It&#8217;s OK to fix a bug without adding a
+new test if it&#8217;s triggered by an existing test case. For example, if a
+race shows up when running a multi-threaded system test after 20
+minutes or so, it&#8217;s worth trying to make a more targeted test case to
+trigger the bug. But if that&#8217;s hard to do, the existing system test
+should be enough.</p>
+</dd>
+<dt class="hdlist1">Tests should run quickly (&lt; 1s).</dt>
+<dd>
+<p>If you want to write a time-intensive
+test, make the runtime dependent on <code>KuduTest#AllowSlowTests</code>, which is
+enabled via the <code>KUDU_ALLOW_SLOW_TESTS</code> environment variable and is
+used by Jenkins test execution.</p>
+</dd>
+<dt class="hdlist1">Tests which run a number of iterations of some task should use a <code>gflags</code> command-line argument for the number of iterations.</dt>
+<dd>
+<p>This is handy for writing quick stress tests or performance tests.</p>
+</dd>
+<dt class="hdlist1">Commits which may affect performance should include before/after <code>perf-stat(1)</code> output.</dt>
+<dd>
+<p>This will show performance improvement or non-regression.
+Performance-sensitive code should include some test case which can be used as a
+targeted benchmark.</p>
+</dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_documentation"><a class="link" href="#_documentation">Documentation</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>See <a href="style_guide.html">Documentation Style Guide</a> for guidelines about contributing
+to the official Kudu documentation.</p>
+</div>
+</div>
+</div>
+    </div>
+    <div class="col-md-3">
+
+  <div id="toc" data-spy="affix" data-offset-top="70">
+  <ul>
+
+      <li>
+
+          <a href="introduction.html">Introducing Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="release_notes.html">Kudu Release Notes</a> 
+      </li> 
+      <li>
+
+          <a href="quickstart.html">Getting Started with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="installation.html">Installation Guide</a> 
+      </li> 
+      <li>
+
+          <a href="configuration.html">Configuring Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="kudu_impala_integration.html">Using Impala with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="administration.html">Administering Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="troubleshooting.html">Troubleshooting Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="developing.html">Developing Applications with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="schema_design.html">Kudu Schema Design</a> 
+      </li> 
+      <li>
+
+          <a href="transaction_semantics.html">Kudu Transaction Semantics</a> 
+      </li> 
+      <li>
+<span class="active-toc">Contributing to Kudu</span>
+            <ul class="sectlevel1">
+<li><a href="#_contributing_patches_using_gerrit">Contributing Patches Using Gerrit</a>
+<ul class="sectlevel2">
+<li><a href="#_initial_setup_for_gerrit">Initial Setup for Gerrit</a></li>
+<li><a href="#_submitting_patches">Submitting Patches</a></li>
+<li><a href="#_abandoning_a_review">Abandoning a Review</a></li>
+<li><a href="#_reviewing_patches_in_gerrit">Reviewing Patches In Gerrit</a></li>
+</ul>
+</li>
+<li><a href="#_code_style">Code Style</a>
+<ul class="sectlevel2">
+<li><a href="#_limitations_on_code_boost_code_library_use">Limitations on <code>boost</code> Library Use</a></li>
+<li><a href="#_line_length">Line length</a></li>
+<li><a href="#_pointers">Pointers</a></li>
+<li><a href="#_function_binding_and_callbacks">Function Binding and Callbacks</a></li>
+<li><a href="#__code_cmake_code_style_guide"><code>CMake</code> Style Guide</a></li>
+<li><a href="#_gflags">GFlags</a></li>
+</ul>
+</li>
+<li><a href="#_testing">Testing</a></li>
+<li><a href="#_documentation">Documentation</a></li>
+</ul> 
+      </li> 
+      <li>
+
+          <a href="style_guide.html">Kudu Documentation Style Guide</a> 
+      </li> 
+      <li>
+
+          <a href="configuration_reference.html">Kudu Configuration Reference</a> 
+      </li> 
+  </ul>
+  </div>
+    </div>
+  </div>
+</div>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/6e3145f8/releases/0.9.1/docs/developing.html
----------------------------------------------------------------------
diff --git a/releases/0.9.1/docs/developing.html b/releases/0.9.1/docs/developing.html
new file mode 100644
index 0000000..1825e5b
--- /dev/null
+++ b/releases/0.9.1/docs/developing.html
@@ -0,0 +1,296 @@
+---
+title: Developing Applications With Apache Kudu (incubating)
+layout: default
+active_nav: docs
+last_updated: 'Last updated 2016-05-24 22:28:30 PDT'
+---
+<!--
+
+Licensed 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.
+-->
+
+
+<div class="container">
+  <div class="row">
+    <div class="col-md-9">
+
+<h1>Developing Applications With Apache Kudu (incubating)</h1>
+      <div id="preamble">
+<div class="sectionbody">
+<div class="paragraph">
+<p>Kudu provides C++ and Java client APIs, as well as reference examples to illustrate
+their use. A Python API is included, but it is currently considered experimental,
+unstable, and subject to change at any time.</p>
+</div>
+<div class="admonitionblock warning">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-warning" title="Warning"></i>
+</td>
+<td class="content">
+Use of server-side or private interfaces is not supported, and interfaces
+which are not part of public APIs have no stability guarantees.
+</td>
+</tr>
+</table>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_viewing_the_api_documentation"><a class="link" href="#_viewing_the_api_documentation">Viewing the API Documentation</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<div class="title">C++ API Documentation</div>
+<p>The documentation for the C++ client APIs is included in the header files in
+<code>/usr/include/kudu/</code> if you installed Kudu using packages or subdirectories
+of <code>src/kudu/client/</code> if you built Kudu from source. If you installed Kudu using parcels,
+no headers are included in your installation. and you will need to <a href="#build_kudu">build
+Kudu from source</a> in order to have access to the headers and shared libraries.</p>
+</div>
+<div class="paragraph">
+<p>The following command is a naive approach to finding relevant header files. Use
+of any APIs other than the client APIs is unsupported.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code class="language-bash" data-lang="bash">$ find /usr/include/kudu -type f -name *.h</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<div class="title">Java API Documentation</div>
+<p>You can view the <a href="../apidocs/index.html">Java API documentation</a> online. Alternatively,
+after <a href="#build_java_client">building the Java client</a>, Java API documentation is available
+in <code>java/kudu-client/target/apidocs/index.html</code>.</p>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_working_examples"><a class="link" href="#_working_examples">Working Examples</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>Several example applications are provided in the
+<a href="https://github.com/cloudera/kudu-examples">kudu-examples</a> Github
+repository. Each example includes a <code>README</code> that shows how to compile and run
+it. These examples illustrate correct usage of the Kudu APIs, as well as how to
+set up a virtual machine to run Kudu. The following list includes some of the
+examples that are available today. Check the repository itself in case this list goes
+out of date.</p>
+</div>
+<div class="dlist">
+<dl>
+<dt class="hdlist1"><code>java-example</code></dt>
+<dd>
+<p>A simple Java application which connects to a Kudu instance, creates a table, writes data to it, then drops the table.</p>
+</dd>
+<dt class="hdlist1"><code>collectl</code></dt>
+<dd>
+<p>A small Java application which listens on a TCP socket for time series data corresponding to the Collectl wire protocol.
+The commonly-available collectl tool can be used to send example data to the server.</p>
+</dd>
+<dt class="hdlist1"><code>clients/python</code></dt>
+<dd>
+<p>An experimental Python client for Kudu.</p>
+</dd>
+<dt class="hdlist1"><code>demo-vm-setup</code></dt>
+<dd>
+<p>Scripts to download and run a VirtualBox virtual machine with Kudu already installed.
+See <a href="quickstart.html">Quickstart</a> for more information.</p>
+</dd>
+</dl>
+</div>
+<div class="paragraph">
+<p>These examples should serve as helpful starting points for your own Kudu applications and integrations.</p>
+</div>
+<div class="sect2">
+<h3 id="_maven_artifacts"><a class="link" href="#_maven_artifacts">Maven Artifacts</a></h3>
+<div class="paragraph">
+<p>The following Maven <code>&lt;dependency&gt;</code> element is valid for the Kudu public beta:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code class="language-xml" data-lang="xml">&lt;dependency&gt;
+  &lt;groupId&gt;org.kududb&lt;/groupId&gt;
+  &lt;artifactId&gt;kudu-client&lt;/artifactId&gt;
+  &lt;version&gt;0.5.0&lt;/version&gt;
+&lt;/dependency&gt;</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>Because the Maven artifacts are not in Maven Central, use the following <code>&lt;repository&gt;</code>
+element:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code class="language-xml" data-lang="xml">&lt;repository&gt;
+  &lt;id&gt;cdh.repo&lt;/id&gt;
+  &lt;name&gt;Cloudera Repositories&lt;/name&gt;
+  &lt;url&gt;https://repository.cloudera.com/artifactory/cloudera-repos&lt;/url&gt;
+  &lt;snapshots&gt;
+    &lt;enabled&gt;false&lt;/enabled&gt;
+  &lt;/snapshots&gt;
+&lt;/repository&gt;</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>See subdirectories of <a href="https://github.com/cloudera/kudu-examples/tree/master/java" class="bare">https://github.com/cloudera/kudu-examples/tree/master/java</a> for
+example Maven pom.xml files.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_example_impala_commands_with_kudu"><a class="link" href="#_example_impala_commands_with_kudu">Example Impala Commands With Kudu</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>See <a href="kudu_impala_integration.html">Using Impala With Kudu</a> for guidance on installing
+and using Impala with Kudu, including several <code>impala-shell</code> examples.</p>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_kudu_integration_with_spark"><a class="link" href="#_kudu_integration_with_spark">Kudu integration with Spark</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>Kudu integrates with spark through the spark data source api as of version 0.9
+Include the kudu-spark using the --jars</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code>spark-shell --jars /kudu-spark-0.9.0.jar</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>Then import kudu-spark and create a dataframe:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlight"><code>// Import kudu datasource
+import org.kududb.spark.kudu._
+val kuduDataFrame =  sqlContext.read.options(Map("kudu.master"-&gt; "your.kudu.master.here","kudu.table"-&gt; "your.kudu.table.here")).kudu
+// Then query using spark api or register a temporary table and use spark sql
+kuduDataFrame.select("id").filter("id"&gt;=5).show()
+// Register kuduDataFrame as a temporary table for spark-sql
+kuduDataFrame.registerTempTable("kudu_table")
+// Select from the dataframe
+sqlContext.sql("select id from kudu_table where id&gt;=5").show()
+
+// create a new kudu table from a dataframe
+val kuduContext = new KuduContext("your.kudu.master.here")
+kuduContext.createTable("testcreatetable", df.schema, Seq("key"), new CreateTableOptions().setNumReplicas(1))
+
+// then we can insert data into the kudu table
+df.write.options(Map("kudu.master"-&gt; "your.kudu.master.here","kudu.table"-&gt; "your.kudu.table.here")).mode("append").kudu
+
+// to update existing data change the mode to 'overwrite'
+df.write.options(Map("kudu.master"-&gt; "your.kudu.master.here","kudu.table"-&gt; "your.kudu.table.here")).mode("overwrite").kudu
+
+// to check for existance of a kudu table
+kuduContext.tableExists("your.kudu.table.here")
+
+// to delete a kudu table
+kuduContext.deleteTable("your.kudu.table.here")</code></pre>
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_integration_with_mapreduce_yarn_and_other_frameworks"><a class="link" href="#_integration_with_mapreduce_yarn_and_other_frameworks">Integration with MapReduce, YARN, and Other Frameworks</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>Kudu was designed to integrate with MapReduce, YARN, Spark, and other frameworks in
+the Hadoop ecosystem. See <a href="https://github.com/apache/incubator-kudu/blob/master/java/kudu-client-tools/src/main/java/org/kududb/mapreduce/tools/RowCounter.java">RowCounter.java</a>
+and
+<a href="https://github.com/apache/incubator-kudu/blob/master/java/kudu-client-tools/src/main/java/org/kududb/mapreduce/tools/ImportCsv.java">ImportCsv.java</a>
+for examples which you can model your own integrations on. Stay tuned for more examples
+using YARN and Spark in the future.</p>
+</div>
+</div>
+</div>
+    </div>
+    <div class="col-md-3">
+
+  <div id="toc" data-spy="affix" data-offset-top="70">
+  <ul>
+
+      <li>
+
+          <a href="introduction.html">Introducing Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="release_notes.html">Kudu Release Notes</a> 
+      </li> 
+      <li>
+
+          <a href="quickstart.html">Getting Started with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="installation.html">Installation Guide</a> 
+      </li> 
+      <li>
+
+          <a href="configuration.html">Configuring Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="kudu_impala_integration.html">Using Impala with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="administration.html">Administering Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="troubleshooting.html">Troubleshooting Kudu</a> 
+      </li> 
+      <li>
+<span class="active-toc">Developing Applications with Kudu</span>
+            <ul class="sectlevel1">
+<li><a href="#_viewing_the_api_documentation">Viewing the API Documentation</a></li>
+<li><a href="#_working_examples">Working Examples</a>
+<ul class="sectlevel2">
+<li><a href="#_maven_artifacts">Maven Artifacts</a></li>
+</ul>
+</li>
+<li><a href="#_example_impala_commands_with_kudu">Example Impala Commands With Kudu</a></li>
+<li><a href="#_kudu_integration_with_spark">Kudu integration with Spark</a></li>
+<li><a href="#_integration_with_mapreduce_yarn_and_other_frameworks">Integration with MapReduce, YARN, and Other Frameworks</a></li>
+</ul> 
+      </li> 
+      <li>
+
+          <a href="schema_design.html">Kudu Schema Design</a> 
+      </li> 
+      <li>
+
+          <a href="transaction_semantics.html">Kudu Transaction Semantics</a> 
+      </li> 
+      <li>
+
+          <a href="contributing.html">Contributing to Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="style_guide.html">Kudu Documentation Style Guide</a> 
+      </li> 
+      <li>
+
+          <a href="configuration_reference.html">Kudu Configuration Reference</a> 
+      </li> 
+  </ul>
+  </div>
+    </div>
+  </div>
+</div>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/6e3145f8/releases/0.9.1/docs/images/kudu-architecture-2.png
----------------------------------------------------------------------
diff --git a/releases/0.9.1/docs/images/kudu-architecture-2.png b/releases/0.9.1/docs/images/kudu-architecture-2.png
new file mode 100644
index 0000000..fcaeba5
Binary files /dev/null and b/releases/0.9.1/docs/images/kudu-architecture-2.png differ

http://git-wip-us.apache.org/repos/asf/incubator-kudu/blob/6e3145f8/releases/0.9.1/docs/index.html
----------------------------------------------------------------------
diff --git a/releases/0.9.1/docs/index.html b/releases/0.9.1/docs/index.html
new file mode 100644
index 0000000..2d61b83
--- /dev/null
+++ b/releases/0.9.1/docs/index.html
@@ -0,0 +1,384 @@
+---
+title: Introducing Apache Kudu (incubating)
+layout: default
+active_nav: docs
+last_updated: 'Last updated 2016-06-23 13:53:47 PDT'
+---
+<!--
+
+Licensed 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.
+-->
+
+
+<div class="container">
+  <div class="row">
+    <div class="col-md-9">
+
+<h1>Introducing Apache Kudu (incubating)</h1>
+      <div id="preamble">
+<div class="sectionbody">
+<div class="paragraph">
+<p>Kudu is a columnar storage manager developed for the Hadoop platform.  Kudu shares
+the common technical properties of Hadoop ecosystem applications: it runs on commodity
+hardware, is horizontally scalable, and supports highly available operation.</p>
+</div>
+<div class="paragraph">
+<p>Kudu&#8217;s design sets it apart. Some of Kudu&#8217;s benefits include:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Fast processing of OLAP workloads.</p>
+</li>
+<li>
+<p>Integration with MapReduce, Spark and other Hadoop ecosystem components.</p>
+</li>
+<li>
+<p>Tight integration with Cloudera Impala, making it a good, mutable alternative
+to using HDFS with Parquet.</p>
+</li>
+<li>
+<p>Strong but flexible consistency model, allowing you to choose consistency
+requirements on a per-request basis, including the option for strict-serializable consistency.</p>
+</li>
+<li>
+<p>Strong performance for running sequential and random workloads simultaneously.</p>
+</li>
+<li>
+<p>Easy to administer and manage with Cloudera Manager.</p>
+</li>
+<li>
+<p>High availability. Tablet Servers and Masters use the <a href="#raft">Raft Consensus Algorithm</a>, which ensures that
+as long as more than half the total number of replicas is available, the tablet is available for
+reads and writes. For instance, if 2 out of 3 replicas or 3 out of 5 replicas are available, the tablet
+is available.</p>
+<div class="paragraph">
+<p>Reads can be serviced by read-only follower tablets, even in the event of a
+leader tablet failure.</p>
+</div>
+</li>
+<li>
+<p>Structured data model.</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>By combining all of these properties, Kudu targets support for families of
+applications that are difficult or impossible to implement on current generation
+Hadoop storage technologies. A few examples of applications for which Kudu is a great
+solution are:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Reporting applications where newly-arrived data needs to be immediately available for end users</p>
+</li>
+<li>
+<p>Time-series applications that must simultaneously support:</p>
+<div class="ulist">
+<ul>
+<li>
+<p>queries across large amounts of historic data</p>
+</li>
+<li>
+<p>granular queries about an individual entity that must return very quickly</p>
+</li>
+</ul>
+</div>
+</li>
+<li>
+<p>Applications that use predictive models to make real-time decisions with periodic
+refreshes of the predictive model based on all historic data</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>For more information about these and other scenarios, see <a href="#kudu_use_cases">Example Use Cases</a>.</p>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_concepts_and_terms"><a class="link" href="#_concepts_and_terms">Concepts and Terms</a></h2>
+<div class="sectionbody">
+<div id="kudu_columnar_data_store" class="paragraph">
+<div class="title">Columnar Data Store</div>
+<p>Kudu is a <em>columnar data store</em>. A columnar data store stores data in strongly-typed
+columns. With a proper design, it is superior for analytical or data warehousing
+workloads for several reasons.</p>
+</div>
+<div class="dlist">
+<dl>
+<dt class="hdlist1">Read Efficiency</dt>
+<dd>
+<p>For analytical queries, you can read a single column, or a portion
+of that column, while ignoring other columns. This means you can fulfill your query
+while reading a minimal number of blocks on disk. With a row-based store, you need
+to read the entire row, even if you only return values from a few columns.</p>
+</dd>
+<dt class="hdlist1">Data Compression</dt>
+<dd>
+<p>Because a given column contains only one type of data, pattern-based
+compression can be orders of magnitude more efficient than compressing mixed data
+types. Combined with the efficiencies of reading data from columns,  compression allows
+you to fulfill your query while reading even fewer blocks from disk. See
+<a href="schema_design.html#encoding">Data Compression</a></p>
+</dd>
+</dl>
+</div>
+<div class="paragraph">
+<div class="title">Table</div>
+<p>A <em>table</em> is where your data is stored in Kudu. A table has a schema and
+a totally ordered primary key. A table is split into segments called tablets.</p>
+</div>
+<div class="paragraph">
+<div class="title">Tablet</div>
+<p>A <em>tablet</em> is a contiguous segment of a table. A given tablet is
+replicated on multiple tablet servers, and one of these replicas is considered
+the leader tablet. Any replica can service reads, and writes require consensus
+among the set of tablet servers serving the tablet.</p>
+</div>
+<div class="paragraph">
+<div class="title">Tablet Server</div>
+<p>A <em>tablet server</em> stores and serves tablets to clients. For a
+given tablet, one tablet server serves the lead tablet, and the others serve
+follower replicas of that tablet. Only leaders service write requests, while
+leaders or followers each service read requests. Leaders are elected using
+<a href="#raft">Raft Consensus Algorithm</a>. One tablet server can serve multiple tablets, and one tablet can be served
+by multiple tablet servers.</p>
+</div>
+<div class="paragraph">
+<div class="title">Master</div>
+<p>The <em>master</em> keeps track of all the tablets, tablet servers, the
+<a href="#catalog_table">Catalog Table</a>, and other metadata related to the cluster. At a given point
+in time, there can only be one acting master (the leader). If the current leader
+disappears, a new master is elected using <a href="#raft">Raft Consensus Algorithm</a>.</p>
+</div>
+<div class="paragraph">
+<p>The master also coordinates metadata operations for clients. For example, when
+creating a new table, the client internally sends an RPC to the master. The
+master writes the metadata for the new table into the catalog table, and
+coordinates the process of creating tablets on the tablet servers.</p>
+</div>
+<div class="paragraph">
+<p>All the master&#8217;s data is stored in a tablet, which can be replicated to all the
+other candidate masters.</p>
+</div>
+<div class="paragraph">
+<p>Tablet servers heartbeat to the master at a set interval (the default is once
+per second).</p>
+</div>
+<div id="raft" class="paragraph">
+<div class="title">Raft Consensus Algorithm</div>
+<p>Kudu uses the <a href="https://raft.github.io/">Raft consensus algorithm</a> as
+a means to guarantee fault-tolerance and consistency, both for regular tablets and for master
+data. Through Raft, multiple replicas of a tablet elect a <em>leader</em>, which is responsible
+for accepting and replicating writes to <em>follower</em> replicas. Once a write is persisted
+in a majority of replicas it is acknowledged to the client. A given group of <code>N</code> replicas
+(usually 3 or 5) is able to accept writes with at most <code>(N - 1)/2</code> faulty replicas.</p>
+</div>
+<div id="catalog_table" class="paragraph">
+<div class="title">Catalog Table</div>
+<p>The <em>catalog table</em> is the central location for
+metadata of Kudu. It stores information about tables and tablets. The catalog
+table is accessible to clients via the master, using the client API.</p>
+</div>
+<div class="dlist">
+<dl>
+<dt class="hdlist1">Tables</dt>
+<dd>
+<p>table schemas, locations, and states</p>
+</dd>
+<dt class="hdlist1">Tablets</dt>
+<dd>
+<p>the list of existing tablets, which tablet servers have replicas of
+each tablet, the tablet&#8217;s current state, and start and end keys.</p>
+</dd>
+</dl>
+</div>
+<div class="paragraph">
+<div class="title">Logical Replication</div>
+<p>Kudu replicates operations, not on-disk data. This is referred to as <em>logical
+replication</em>, as opposed to <em>physical replication</em>. Physical operations, such as
+compaction, do not need to transmit the data over the network. This results in a
+substantial reduction in network traffic for heavy write scenarios.</p>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_architectural_overview"><a class="link" href="#_architectural_overview">Architectural Overview</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>The following diagram shows a Kudu cluster with three masters and multiple tablet
+servers, each serving multiple tablets. It illustrates how Raft consensus is used
+to allow for both leaders and followers for both the masters and tablet servers. In
+addition, a tablet server can be a leader for some tablets, and a follower for others.
+Leaders are shown in gold, while followers are shown in blue.</p>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-note" title="Note"></i>
+</td>
+<td class="content">
+Multiple masters are not supported during the Kudu beta period.
+</td>
+</tr>
+</table>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="./images/kudu-architecture-2.png" alt="Kudu Architecture" width="800">
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="kudu_use_cases"><a class="link" href="#kudu_use_cases">Example Use Cases</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<div class="title">Streaming Input with Near Real Time Availability</div>
+<p>A common challenge in data analysis is one where new data arrives rapidly and constantly,
+and the same data needs to be available in near real time for reads, scans, and
+updates. Kudu offers the powerful combination of fast inserts and updates with
+efficient columnar scans to enable real-time analytics use cases on a single storage layer.</p>
+</div>
+<div class="paragraph">
+<div class="title">Time-series application with widely varying access patterns</div>
+<p>A time-series schema is one in which data points are organized and keyed according
+to the time at which they occurred. This can be useful for investigating the
+performance of metrics over time or attempting to predict future behavior based
+on past data. For instance, time-series customer data might be used both to store
+purchase click-stream history and to predict future purchases, or for use by a
+customer support representative. While these different types of analysis are occurring,
+inserts and mutations may also be occurring individually and in bulk, and become available
+immediately to read workloads. Kudu can handle all of these access patterns
+simultaneously in a scalable and efficient manner.</p>
+</div>
+<div class="paragraph">
+<p>Kudu is a good fit for time-series workloads for several reasons. With Kudu&#8217;s support for
+hash-based partitioning, combined with its native support for compound row keys, it is
+simple to set up a table spread across many servers without the risk of "hotspotting"
+that is commonly observed when range partitioning is used. Kudu&#8217;s columnar storage engine
+is also beneficial in this context, because many time-series workloads read only a few columns,
+as opposed to the whole row.</p>
+</div>
+<div class="paragraph">
+<p>In the past, you might have needed to use multiple data stores to handle different
+data access patterns. This practice adds complexity to your application and operations, and
+duplicates storage. Kudu can handle all of these access patterns natively and efficiently,
+without the need to off-load work to other data stores.</p>
+</div>
+<div class="paragraph">
+<div class="title">Predictive Modeling</div>
+<p>Data analysts often develop predictive learning models from large sets of data. The
+model and the data may need to be updated or modified often as the learning takes
+place or as the situation being modeled changes. In addition, the scientist may want
+to change one or more factors in the model to see what happens over time. Updating
+a large set of data stored in files in HDFS is resource-intensive, as each file needs
+to be completely rewritten. In Kudu, updates happen in near real time. The scientist
+can tweak the value, re-run the query, and refresh the graph in seconds or minutes,
+rather than hours or days. In addition, batch or incremental algorithms can be run
+across the data at any time, with near-real-time results.</p>
+</div>
+<div class="paragraph">
+<div class="title">Combining Data In Kudu With Legacy Systems</div>
+<p>Companies generate data from multiple sources and store it in a variety of systems
+and formats. For instance, some of your data may be stored in Kudu, some in a traditional
+RDBMS, and some in files in HDFS. You can access and query all of these sources and
+formats using Impala, without the need to change your legacy systems.</p>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="_next_steps"><a class="link" href="#_next_steps">Next Steps</a></h2>
+<div class="sectionbody">
+<div class="ulist">
+<ul>
+<li>
+<p><a href="quickstart.html">Get Started With Kudu</a></p>
+</li>
+<li>
+<p><a href="installation.html">Installing Kudu</a></p>
+</li>
+</ul>
+</div>
+</div>
+</div>
+    </div>
+    <div class="col-md-3">
+
+  <div id="toc" data-spy="affix" data-offset-top="70">
+  <ul>
+
+      <li>
+
+          <a href="introduction.html">Introducing Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="release_notes.html">Kudu Release Notes</a> 
+      </li> 
+      <li>
+
+          <a href="quickstart.html">Getting Started with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="installation.html">Installation Guide</a> 
+      </li> 
+      <li>
+
+          <a href="configuration.html">Configuring Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="kudu_impala_integration.html">Using Impala with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="administration.html">Administering Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="troubleshooting.html">Troubleshooting Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="developing.html">Developing Applications with Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="schema_design.html">Kudu Schema Design</a> 
+      </li> 
+      <li>
+
+          <a href="transaction_semantics.html">Kudu Transaction Semantics</a> 
+      </li> 
+      <li>
+
+          <a href="contributing.html">Contributing to Kudu</a> 
+      </li> 
+      <li>
+
+          <a href="style_guide.html">Kudu Documentation Style Guide</a> 
+      </li> 
+      <li>
+
+          <a href="configuration_reference.html">Kudu Configuration Reference</a> 
+      </li> 
+  </ul>
+  </div>
+    </div>
+  </div>
+</div>
\ No newline at end of file


Mime
View raw message