accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mwa...@apache.org
Subject [2/2] accumulo-website git commit: Jekyll build from master:e0da132
Date Fri, 26 May 2017 14:56:59 GMT
Jekyll build from master:e0da132

Documentation updates

* Added javadocs links to iterators.md
* Fixed headers on proxy.md


Project: http://git-wip-us.apache.org/repos/asf/accumulo-website/repo
Commit: http://git-wip-us.apache.org/repos/asf/accumulo-website/commit/3f99b6cc
Tree: http://git-wip-us.apache.org/repos/asf/accumulo-website/tree/3f99b6cc
Diff: http://git-wip-us.apache.org/repos/asf/accumulo-website/diff/3f99b6cc

Branch: refs/heads/asf-site
Commit: 3f99b6cc928c3071156878beb1134dcf0e2f7108
Parents: 9ebc5f9
Author: Mike Walch <mwalch@apache.org>
Authored: Fri May 26 10:56:13 2017 -0400
Committer: Mike Walch <mwalch@apache.org>
Committed: Fri May 26 10:56:13 2017 -0400

----------------------------------------------------------------------
 docs/unreleased/development/iterators.html | 68 ++++++++++++-------------
 docs/unreleased/development/proxy.html     | 14 +++--
 feed.xml                                   |  4 +-
 3 files changed, 42 insertions(+), 44 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/3f99b6cc/docs/unreleased/development/iterators.html
----------------------------------------------------------------------
diff --git a/docs/unreleased/development/iterators.html b/docs/unreleased/development/iterators.html
index b890a7c..64cbea4 100644
--- a/docs/unreleased/development/iterators.html
+++ b/docs/unreleased/development/iterators.html
@@ -317,7 +317,7 @@
     
     <h1>Iterators</h1>
     
-    <p>Accumulo SortedKeyValueIterators, commonly referred to as <strong>Iterators</strong>
for short, are server-side programming constructs
+    <p>Accumulo <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/SortedKeyValueIterator.html">SortedKeyValueIterators</a>,
commonly referred to as <strong>Iterators</strong> for short, are server-side
programming constructs
 that allow users to implement custom retrieval or computational purpose within Accumulo TabletServers.
 The name rightly
 brings forward similarities to the Java Iterator interface; however, Accumulo Iterators are
more complex than Java
 Iterators. Notably, in addition to the expected methods to retrieve the current element and
advance to the next element
@@ -329,7 +329,7 @@ merge multiple Iterators into a single view. In this sense, a collection
of Iter
 a tree-structure than a list, but there is always a sense of a flow of Key-Value pairs through
some Iterators. Iterators
 are not designed to act as triggers nor are they designed to operate outside of the purview
of a single table.</p>
 
-<p>Understanding how TabletServers invoke the methods on a SortedKeyValueIterator can
be obtuse as the actual code is
+<p>Understanding how TabletServers invoke the methods on a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/SortedKeyValueIterator.html">SortedKeyValueIterator</a>
can be obtuse as the actual code is
 buried within the implementation of the TabletServer; however, it is generally unnecessary
to have a strong
 understanding of this as the interface provides clear definitions about what each action
each method should take. This
 chapter aims to provide a more detailed description of how Iterators are invoked, some best
practices and some common
@@ -350,7 +350,7 @@ Iterators must have a public no-args constructor.</p>
 
 <h2 id="interface">Interface</h2>
 
-<p>A normal implementation of the SortedKeyValueIterator defines functionality for
the following methods:</p>
+<p>A normal implementation of the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/SortedKeyValueIterator.html">SortedKeyValueIterator</a>
defines functionality for the following methods:</p>
 
 <div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="kt">void</span> <span class="nf">init</span><span class="o">(</span><span
class="n">SortedKeyValueIterator</span><span class="o">&lt;</span><span
class="n">Key</span><span class="o">,</span><span class="n">Value</span><span
class="o">&gt;</span> <span class="n">source</span><span class="o">,</span>
<span class="n">Map</span><span class="o">&lt;</span><span
class="n">String</span><span class="o">,</span><span class="n">String</span><span
class="o">&gt;</span> <span class="n">options</span><span class="o">,</span>
<span class="n">IteratorEnvironment</span> <span class="n">env</span><span
class="o">)</span> <span class="kd">throws</span> <span class="n">IOException</span><span
class="o">;</span>
 
@@ -381,7 +381,7 @@ These options allow for Iterators to dynamically configure themselves
on the fly
 (a Scan or Compaction), the Map will be empty. An example of a configuration item for an
Iterator could be a pattern used to filter
 Key-Value pairs in a regular expression Iterator.</p>
 
-<p>The third argument, the <code class="highlighter-rouge">IteratorEnvironment</code>,
is a special object which provides information to this Iterator about the
+<p>The third argument, the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/IteratorEnvironment.html">IteratorEnvironment</a>,
is a special object which provides information to this Iterator about the
 context in which it was invoked. Commonly, this information is not necessary to inspect.
For example, if an Iterator
 knows that it is running in the context of a full-major compaction (reading all of the data)
as opposed to a user scan
 (which may strongly limit the number of columns), the Iterator might make different algorithmic
decisions in an attempt to
@@ -392,7 +392,7 @@ optimize itself.</p>
 <p>The <code class="highlighter-rouge">seek</code> method is likely the
most confusing method on the Iterator interface. The purpose of this method is to
 advance the stream of Key-Value pairs to a certain point in the iteration (the Accumulo table).
It is common that before
 the implementation of this method returns some additional processing is performed which may
further advance the current
-position past the <code class="highlighter-rouge">startKey</code> of the <code
class="highlighter-rouge">Range</code>. This, however, is dependent on the functionality
the iterator provides. For
+position past the <code class="highlighter-rouge">startKey</code> of the <a
href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>.
This, however, is dependent on the functionality the iterator provides. For
 example, a filtering iterator would consume a number Key-Value pairs which do not meets its
criteria before <code class="highlighter-rouge">seek</code>
 returns. The important condition for <code class="highlighter-rouge">seek</code>
to meet is that this Iterator should be ready to return the first Key-Value
 pair, or none if no such pair is available, when the method returns. The Key-Value pair would
be returned by <code class="highlighter-rouge">getTopKey</code>
@@ -401,8 +401,8 @@ a Key-Value pair to return.</p>
 
 <p>The arguments passed to seek are as follows:</p>
 
-<p>The TabletServer first provides a <code class="highlighter-rouge">Range</code>,
an object which defines some collection of Accumulo <code class="highlighter-rouge">Key</code>s,
which defines the
-Key-Value pairs that this Iterator should return. Each <code class="highlighter-rouge">Range</code>
has a <code class="highlighter-rouge">startKey</code> and <code class="highlighter-rouge">endKey</code>
with an inclusive flag for
+<p>The TabletServer first provides a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>,
an object which defines some collection of Accumulo <code class="highlighter-rouge">Key</code>s,
which defines the
+Key-Value pairs that this Iterator should return. Each <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
has a <code class="highlighter-rouge">startKey</code> and <code class="highlighter-rouge">endKey</code>
with an inclusive flag for
 both. While this Range is often similar to the Range(s) set by the client on a Scanner or
BatchScanner, it is not
 guaranteed to be a Range that the client set. Accumulo will split up larger ranges and group
them together based on
 Tablet boundaries per TabletServer. Iterators should not attempt to implement any custom
logic based on the Range(s)
@@ -414,12 +414,12 @@ should be treated as an inclusion collection (true) or an exclusion
collection (
 
 <p>It is likely that all implementations of <code class="highlighter-rouge">seek</code>
will first make a call to the <code class="highlighter-rouge">seek</code> method
on the
 “source” Iterator that was provided in the <code class="highlighter-rouge">init</code>
method. The collection of column families and
-the boolean <code class="highlighter-rouge">include</code> argument should be
passed down as well as the <code class="highlighter-rouge">Range</code>. Somewhat
commonly, the Iterator will
+the boolean <code class="highlighter-rouge">include</code> argument should be
passed down as well as the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>.
Somewhat commonly, the Iterator will
 also implement some sort of additional logic to find or compute the first Key-Value pair
in the provided
 Range. For example, a regular expression Iterator would consume all records which do not
match the given
 pattern before returning from <code class="highlighter-rouge">seek</code>.</p>
 
-<p>It is important to retain the original Range passed to this method to know when
this Iterator should stop
+<p>It is important to retain the original <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
passed to this method to know when this Iterator should stop
 reading more Key-Value pairs. Ignoring this typically does not affect scans from a Scanner,
but it
 will result in duplicate keys emitting from a BatchScan if the scanned table has more than
one tablet.
 Best practice is to never emit entries outside the seek range.</p>
@@ -471,12 +471,12 @@ returned from <code class="highlighter-rouge">getTopKey</code>/<code
class="high
 Implementations of this method should return a new object of the same type as the Accumulo
Iterator
 instance it was called on. Any internal state from the instance <code class="highlighter-rouge">deepCopy</code>
was called
 on should be carried over to the returned copy. The returned copy should be ready to have
-<code class="highlighter-rouge">seek</code> called on it. The SortedKeyValueIterator
interface guarantees that <code class="highlighter-rouge">init</code> will be
called on
+<code class="highlighter-rouge">seek</code> called on it. The <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/SortedKeyValueIterator.html">SortedKeyValueIterator</a>
interface guarantees that <code class="highlighter-rouge">init</code> will be
called on
 an iterator before <code class="highlighter-rouge">deepCopy</code> and that <code
class="highlighter-rouge">init</code> will not be called on the iterator returned
by
 <code class="highlighter-rouge">deepCopy</code>.</p>
 
 <p>Typically, implementations of <code class="highlighter-rouge">deepCopy</code>
call a copy-constructor which will initialize
-internal data structures. As with <code class="highlighter-rouge">seek</code>,
it is common for the <code class="highlighter-rouge">IteratorEnvironment</code>
+internal data structures. As with <code class="highlighter-rouge">seek</code>,
it is common for the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/IteratorEnvironment.html">IteratorEnvironment</a>
 argument to be ignored as most Iterator implementations can be written without the explicit
 information the environment provides.</p>
 
@@ -561,18 +561,18 @@ next possible row.</p>
 <h2 id="abstract-iterators">Abstract Iterators</h2>
 
 <p>A number of Abstract implementations of Iterators are provided to allow for faster
creation
-of common patterns. The most commonly used abstract implementations are the <code class="highlighter-rouge">Filter</code>
and
-<code class="highlighter-rouge">Combiner</code> classes. When possible these
classes should be used instead as they have been
+of common patterns. The most commonly used abstract implementations are the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Filter.html">Filter</a>
and
+<a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Combiner.html">Combiner</a>
classes. When possible these classes should be used instead as they have been
 thoroughly tested inside Accumulo itself.</p>
 
 <h3 id="filter">Filter</h3>
 
-<p>The <code class="highlighter-rouge">Filter</code> abstract Iterator
provides a very simple implementation which allows implementations
+<p>The <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Filter.html">Filter</a>
abstract Iterator provides a very simple implementation which allows implementations
 to define whether or not a Key-Value pair should be returned via an <code class="highlighter-rouge">accept(Key,
Value)</code> method.</p>
 
 <p>Filters are extremely simple to implement; however, when the implementation is filtering
a
 large percentage of Key-Value pairs with respect to the total number of pairs examined,
-it can be very inefficient. For example, if a Filter implementation can determine after examining
+it can be very inefficient. For example, if a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Filter.html">Filter</a>
implementation can determine after examining
 part of the row that no other pairs in this row will be accepted, there is no mechanism to
 efficiently skip the remaining Key-Value pairs. Concretely, take a row which is comprised
of
 1000 Key-Value pairs. After examining the first 10 Key-Value pairs, it is determined
@@ -581,30 +581,30 @@ remaining 990 Key-Value pairs in this row. Another way to express this
deficienc
 Filters have no means to leverage the <code class="highlighter-rouge">seek</code>
method to efficiently skip large portions
 of Key-Value pairs.</p>
 
-<p>As such, the <code class="highlighter-rouge">Filter</code> class functions
well for filtering small amounts of data, but is
-inefficient for filtering large amounts of data. The decision to use a <code class="highlighter-rouge">Filter</code>
strongly
+<p>As such, the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Filter.html">Filter</a>
class functions well for filtering small amounts of data, but is
+inefficient for filtering large amounts of data. The decision to use a Filter strongly
 depends on the use case and distribution of data being filtered.</p>
 
 <h3 id="combiner">Combiner</h3>
 
-<p>The <code class="highlighter-rouge">Combiner</code> class is another
common abstract Iterator. Similar to the <code class="highlighter-rouge">Combiner</code>
interface
+<p>The <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Combiner.html">Combiner</a>
class is another common abstract Iterator. Similar to the <code class="highlighter-rouge">Combiner</code>
interface
 define in Hadoop’s MapReduce framework, implementations of this abstract class reduce
 multiple Values for different versions of a Key (Keys which only differ by timestamps) into
one Key-Value pair.
 Combiners provide a simple way to implement common operations like summation and
 aggregation without the need to implement the entire Accumulo Iterator interface.</p>
 
-<p>One important consideration when choosing to design a Combiner is that the “reduction”
operation
+<p>One important consideration when choosing to design a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Combiner.html">Combiner</a>
is that the “reduction” operation
 is often best represented when it is associative and commutative. Operations which do not
meet
 these criteria can be implemented; however, the implementation can be difficult.</p>
 
-<p>A second consideration is that a Combiner is not guaranteed to see every Key-Value
pair
+<p>A second consideration is that a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Combiner.html">Combiner</a>
is not guaranteed to see every Key-Value pair
 which differ only by timestamp every time it is invoked. For example, if there are 5 Key-Value
 pairs in a table which only differ by the timestamps 1, 2, 3, 4, and 5, it is not guaranteed
that
 every invocation of the Combiner will see 5 timestamps. One invocation might see the Values
for
 Keys with timestamp 1 and 4, while another invocation might see the Values for Keys with
the
 timestamps 1, 2, 4 and 5.</p>
 
-<p>Finally, when configuring an Accumulo table to use a Combiner, be sure to disable
the Versioning Iterator or set the
+<p>Finally, when configuring an Accumulo table to use a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Combiner.html">Combiner</a>,
be sure to disable the Versioning Iterator or set the
 Combiner at a priority less than the Combiner (the Versioning Iterator is added at a priority
of 20 by default). The
 Versioning Iterator will filter out multiple Key-Value pairs that differ only by timestamp
and return only the Key-Value
 pair that has the largest timestamp.</p>
@@ -612,7 +612,7 @@ pair that has the largest timestamp.</p>
 <h4 id="combiner-applications">Combiner Applications</h4>
 
 <p>Many applications can benefit from the ability to aggregate values across common
-keys. This can be done via Combiner iterators and is similar to the Reduce step in
+keys. This can be done via <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Combiner.html">Combiner</a>
iterators and is similar to the Reduce step in
 MapReduce. This provides the ability to define online, incrementally updated
 analytics without the overhead or latency associated with batch-oriented
 MapReduce jobs.</p>
@@ -637,16 +637,16 @@ combining iterator.</p>
 
 <h2 id="best-practices">Best practices</h2>
 
-<p>Because of the flexibility that the <code class="highlighter-rouge">SortedKeyValueInterface</code>
provides, it doesn’t directly disallow
+<p>Because of the flexibility that the [SortedKeyValueInterface] provides, it doesn’t
directly disallow
 many implementations which are poor design decisions. The following are some common recommendations
to
 follow and pitfalls to avoid in Iterator implementations.</p>
 
 <h4 id="avoid-special-logic-encoded-in-ranges">Avoid special logic encoded in Ranges</h4>
 
 <p>Commonly, granular Ranges that a client passes to an Iterator from a <code class="highlighter-rouge">Scanner</code>
or <code class="highlighter-rouge">BatchScanner</code> are unmodified.
-If a <code class="highlighter-rouge">Range</code> falls within the boundaries
of a Tablet, an Iterator will often see that same Range in the
-<code class="highlighter-rouge">seek</code> method. However, there is no guarantee
that the <code class="highlighter-rouge">Range</code> will remain unaltered from
client to server. As such, Iterators
-should <em>never</em> make assumptions about the current state/context based
on the <code class="highlighter-rouge">Range</code>.</p>
+If a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
falls within the boundaries of a Tablet, an Iterator will often see that same Range in the
+<code class="highlighter-rouge">seek</code> method. However, there is no guarantee
that the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
will remain unaltered from client to server. As such, Iterators
+should <em>never</em> make assumptions about the current state/context based
on the Range.</p>
 
 <p>The common failure condition is referred to as a “re-seek”. In the context of
a Scan, TabletServers construct the
 “stack” of Iterators and batch up Key-Value pairs to send back to the client. When a
sufficient number of Key-Value
@@ -657,24 +657,24 @@ the point to resume the iteration (to avoid returning duplicate Key-Value
pairs)
 from the original but is shortened by setting the startKey of the original Range to the Key
last returned by the Scan,
 non-inclusive.</p>
 
-<h3 id="seeking-backwards"><code class="highlighter-rouge">seek</code>‘ing
backwards</h3>
+<h3 id="seeking-backwards">seeking backwards</h3>
 
 <p>The ability for an Iterator to “skip over” large blocks of Key-Value pairs is
a major tenet behind Iterators.
 By <code class="highlighter-rouge">seek</code>‘ing when it is known that there
is a collection of Key-Value pairs which can be ignored can
 greatly increase the speed of a scan as many Key-Value pairs do not have to be deserialized
and processed.</p>
 
-<p>While the <code class="highlighter-rouge">seek</code> method provides
the <code class="highlighter-rouge">Range</code> that should be used to <code
class="highlighter-rouge">seek</code> the underlying source Iterator,
-there is no guarantee that the implementing Iterator uses that <code class="highlighter-rouge">Range</code>
to perform the <code class="highlighter-rouge">seek</code> on its
-“source” Iterator. As such, it is possible to seek to any <code class="highlighter-rouge">Range</code>
and the interface has no assertions
+<p>While the <code class="highlighter-rouge">seek</code> method provides
the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
that should be used to <code class="highlighter-rouge">seek</code> the underlying
source Iterator,
+there is no guarantee that the implementing Iterator uses that Range to perform the <code
class="highlighter-rouge">seek</code> on its
+“source” Iterator. As such, it is possible to seek to any Range and the interface has
no assertions
 to prevent this from happening.</p>
 
 <p>Since Iterators are allowed to <code class="highlighter-rouge">seek</code>
to arbitrary Keys, it also allows Iterators to create infinite loops
-inside Scans that will repeatedly read the same data without end. If an arbitrary Range is
constructed, it should
+inside Scans that will repeatedly read the same data without end. If an arbitrary <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
is constructed, it should
 construct a completely new Range as it allows for bugs to be introduced which will break
Accumulo.</p>
 
 <p>Thus, <code class="highlighter-rouge">seek</code>’s should always
be thought of as making “forward progress” in the view of the total iteration. The
-<code class="highlighter-rouge">startKey</code> of a <code class="highlighter-rouge">Range</code>
should always be greater than the current Key seen by the Iterator while the <code class="highlighter-rouge">endKey</code>
of the
-<code class="highlighter-rouge">Range</code> should always retain the original
<code class="highlighter-rouge">endKey</code> (and <code class="highlighter-rouge">endKey</code>
inclusivity) of the last <code class="highlighter-rouge">Range</code> seen by
your
+<code class="highlighter-rouge">startKey</code> of a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
should always be greater than the current Key seen by the Iterator while the <code class="highlighter-rouge">endKey</code>
of the
+Range should always retain the original <code class="highlighter-rouge">endKey</code>
(and <code class="highlighter-rouge">endKey</code> inclusivity) of the last Range
seen by your
 Iterator’s implementation of seek.</p>
 
 <h3 id="take-caution-in-constructing-new-data-in-an-iterator">Take caution in constructing
new data in an Iterator</h3>
@@ -722,7 +722,7 @@ to make different assertions than those who only operate at scan time.
Iterators
 Iterators will not necessarily see all of the Key-Value pairs in ever invocation. Because
compactions often do not rewrite
 all files (only a subset of them), it is possible that the logic take this into consideration.</p>
 
-<p>For example, a Combiner that runs over data at during compactions, might not see
all of the values for a given Key. The
+<p>For example, a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/iterators/Combiner.html">Combiner</a>
that runs over data at during compactions, might not see all of the values for a given Key.
The
 Combiner must recognize this and not perform any function that would be incorrect due
 to the missing values.</p>
 

http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/3f99b6cc/docs/unreleased/development/proxy.html
----------------------------------------------------------------------
diff --git a/docs/unreleased/development/proxy.html b/docs/unreleased/development/proxy.html
index 2dd8a1f..4df16bc 100644
--- a/docs/unreleased/development/proxy.html
+++ b/docs/unreleased/development/proxy.html
@@ -317,21 +317,19 @@
     
     <h1>Proxy</h1>
     
-    <h2 id="proxy">Proxy</h2>
-
-<p>The proxy API allows the interaction with Accumulo with languages other than Java.
+    <p>The proxy API allows the interaction with Accumulo with languages other than
Java.
 A proxy server is provided in the codebase and a client can further be generated.
 The proxy API can also be used instead of the traditional ZooKeeperInstance class to
 provide a single TCP port in which clients can be securely routed through a firewall,
 without requiring access to all tablet servers in the cluster.</p>
 
-<h3 id="prerequisites">Prerequisites</h3>
+<h2 id="prerequisites">Prerequisites</h2>
 
 <p>The proxy server can live on any node in which the basic client API would work.
That
 means it must be able to communicate with the Master, ZooKeepers, NameNode, and the
 DataNodes. A proxy client only needs the ability to communicate with the proxy server.</p>
 
-<h3 id="configuration">Configuration</h3>
+<h2 id="configuration">Configuration</h2>
 
 <p>The configuration options for the proxy server live inside of a properties file.
At
 the very least, you need to supply the following properties:</p>
@@ -349,7 +347,7 @@ zookeepers=localhost:2181
 <p>This sample configuration file further demonstrates an ability to back the proxy
server
 by MockAccumulo or the MiniAccumuloCluster.</p>
 
-<h3 id="running-the-proxy-server">Running the Proxy Server</h3>
+<h2 id="running-the-proxy-server">Running the Proxy Server</h2>
 
 <p>After the properties file holding the configuration is created, the proxy server
 can be started using the following command in the Accumulo distribution (assuming
@@ -359,7 +357,7 @@ your properties file is named <code class="highlighter-rouge">config.properties<
 </code></pre>
 </div>
 
-<h3 id="creating-a-proxy-client">Creating a Proxy Client</h3>
+<h2 id="creating-a-proxy-client">Creating a Proxy Client</h2>
 
 <p>Aside from installing the Thrift compiler, you will also need the language-specific
library
 for Thrift installed to generate client code in that language. Typically, your operating
@@ -371,7 +369,7 @@ location such as <code class="highlighter-rouge">/usr/lib/python/site-packages/t
 <p>After a client is generated, the port specified in the configuration properties
above will be
 used to connect to the server.</p>
 
-<h3 id="using-a-proxy-client">Using a Proxy Client</h3>
+<h2 id="using-a-proxy-client">Using a Proxy Client</h2>
 
 <p>The following examples have been written in Java and the method signatures may be
 slightly different depending on the language specified when generating client with

http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/3f99b6cc/feed.xml
----------------------------------------------------------------------
diff --git a/feed.xml b/feed.xml
index f42b2b8..07c2df6 100644
--- a/feed.xml
+++ b/feed.xml
@@ -6,8 +6,8 @@
 </description>
     <link>https://accumulo.apache.org/</link>
     <atom:link href="https://accumulo.apache.org/feed.xml" rel="self" type="application/rss+xml"/>
-    <pubDate>Fri, 26 May 2017 10:16:13 -0400</pubDate>
-    <lastBuildDate>Fri, 26 May 2017 10:16:13 -0400</lastBuildDate>
+    <pubDate>Fri, 26 May 2017 10:56:05 -0400</pubDate>
+    <lastBuildDate>Fri, 26 May 2017 10:56:05 -0400</lastBuildDate>
     <generator>Jekyll v3.3.1</generator>
     
       <item>


Mime
View raw message