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 <[email protected]> Authored: Fri May 26 10:56:13 2017 -0400 Committer: Mike Walch <[email protected]> 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"><</span><span class="n">Key</span><span class="o">,</span><span class="n">Value</span><span class="o">></span> <span class="n">source</span><span class="o">,</span> <span class="n">Map</span><span class="o"><</span><span class="n">String</span><span class="o">,</span><span class="n">String</span><span class="o">></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>
