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:a33b3ed
Date Wed, 31 May 2017 18:33:36 GMT
Jekyll build from master:a33b3ed

Improvemnts to documentation and verifying release page


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

Branch: refs/heads/asf-site
Commit: 41adefb69b6a054675cc29c158473173c5ad9327
Parents: 1e7c974
Author: Mike Walch <mwalch@apache.org>
Authored: Wed May 31 14:33:02 2017 -0400
Committer: Mike Walch <mwalch@apache.org>
Committed: Wed May 31 14:33:02 2017 -0400

----------------------------------------------------------------------
 contributor/verifying-release.html              |  10 +-
 .../development/development_tools.html          | 160 +++++++------------
 .../development/high_speed_ingest.html          |  16 +-
 docs/unreleased/development/security.html       |  55 ++++---
 docs/unreleased/getting-started/shell.html      |  56 ++-----
 feed.xml                                        |   4 +-
 6 files changed, 116 insertions(+), 185 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/41adefb6/contributor/verifying-release.html
----------------------------------------------------------------------
diff --git a/contributor/verifying-release.html b/contributor/verifying-release.html
index 3cef55a..1775668 100644
--- a/contributor/verifying-release.html
+++ b/contributor/verifying-release.html
@@ -171,11 +171,11 @@ trumps anything written here.</p>
 property in the <code class="highlighter-rouge">pom.xml</code> and using the
staging repo. Also, run the unit/integration tests using <code class="highlighter-rouge">mvn
verify</code>.</p>
   </li>
   <li>
-    <p>Run Accumulo’s distributed tests (i.e RandomWalk, ContinuousIngest, etc).
Information on these tests can
-be found in their respective directories, <code class="highlighter-rouge">test/system/randomwalk</code>
and <code class="highlighter-rouge">test/system/continuous</code>, which
-include instructions on how to run the tests. These tests are intended to be run for days
on end while
-injecting faults into the system. These are the tests that truly verify the correctness of
Accumulo on
-real systems.</p>
+    <p>Run Accumulo’s distributed tests (i.e. random walk, continous ingest). These
tests are intended to be run for days
+on end while injecting faults into the system. These are the tests that truly verify the
correctness of Accumulo on
+real systems. Starting with 2.0, these tests are run using the <a href="https://github.com/apache/accumulo-testing">Accumulo
Testing repo</a>. See the <a href="https://github.com/apache/accumulo-testing/blob/master/README.md">README.md</a>
+for more information.  Before 2.0, these tests are found in Accumulo tarball at <code
class="highlighter-rouge">test/system/randomwalk</code> and
+<code class="highlighter-rouge">test/system/continuous</code> which include instructions
on how to run the tests.</p>
   </li>
 </ul>
 

http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/41adefb6/docs/unreleased/development/development_tools.html
----------------------------------------------------------------------
diff --git a/docs/unreleased/development/development_tools.html b/docs/unreleased/development/development_tools.html
index 4756323..195508e 100644
--- a/docs/unreleased/development/development_tools.html
+++ b/docs/unreleased/development/development_tools.html
@@ -317,10 +317,49 @@
     
     <h1>Development Tools</h1>
     
-    <p>Normally, Accumulo consists of lots of moving parts. Even a stand-alone version
of
-Accumulo requires Hadoop, Zookeeper, the Accumulo master, a tablet server, etc. If
-you want to write a unit test that uses Accumulo, you need a lot of infrastructure
-in place before your test can run.</p>
+    <p>Accumulo has several tools that can help developers test their code.</p>
+
+<h2 id="miniaccumulocluster">MiniAccumuloCluster</h2>
+
+<p><a href="https://static.javadoc.io/org.apache.accumulo/accumulo-minicluster/1.8.1/org/apache/accumulo/minicluster/MiniAccumuloCluster.html">MiniAccumuloCluster</a>
is a standalone instance of Apache Accumulo for testing. It will
+create Zookeeper and Accumulo processes that write all of their data to a single local
+directory. <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-minicluster/1.8.1/org/apache/accumulo/minicluster/MiniAccumuloCluster.html">MiniAccumuloCluster</a>
makes it easy to code agaist a real Accumulo instance.
+Developers can write realistic-to-end integration tests that mimic the use of a normal
+Accumulo instance.</p>
+
+<p><a href="https://static.javadoc.io/org.apache.accumulo/accumulo-minicluster/1.8.1/org/apache/accumulo/minicluster/MiniAccumuloCluster.html">MiniAccumuloCluster</a>
is published in a separate jar that should be added to your pom.xml
+as a test dependency:</p>
+
+<div class="language-xml highlighter-rouge"><pre class="highlight"><code><span
class="nt">&lt;dependency&gt;</span>
+  <span class="nt">&lt;groupId&gt;</span>org.apache.accumulo<span
class="nt">&lt;/groupId&gt;</span>
+  <span class="nt">&lt;artifactId&gt;</span>accumulo-minicluster<span
class="nt">&lt;/artifactId&gt;</span>
+  <span class="nt">&lt;version&gt;</span>${accumulo.version}<span
class="nt">&lt;/version&gt;</span>
+  <span class="nt">&lt;scope&gt;</span>test<span class="nt">&lt;/scope&gt;</span>
+<span class="nt">&lt;/dependency&gt;</span>
+</code></pre>
+</div>
+
+<p>To start it up, you will need to supply an empty directory and a root password as
arguments:</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">File</span> <span class="n">tempDirectory</span> <span class="o">=</span>
<span class="c1">// JUnit and Guava supply mechanisms for creating temp directories</span>
+<span class="n">MiniAccumuloCluster</span> <span class="n">accumulo</span>
<span class="o">=</span> <span class="k">new</span> <span class="n">MiniAccumuloCluster</span><span
class="o">(</span><span class="n">tempDirectory</span><span class="o">,</span>
<span class="s">"password"</span><span class="o">);</span>
+<span class="n">accumulo</span><span class="o">.</span><span class="na">start</span><span
class="o">();</span>
+</code></pre>
+</div>
+
+<p>Once we have our mini cluster running, we will want to interact with the Accumulo
client API:</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">Instance</span> <span class="n">instance</span> <span class="o">=</span>
<span class="k">new</span> <span class="n">ZooKeeperInstance</span><span
class="o">(</span><span class="n">accumulo</span><span class="o">.</span><span
class="na">getInstanceName</span><span class="o">(),</span> <span
class="n">accumulo</span><span class="o">.</span><span class="na">getZooKeepers</span><span
class="o">());</span>
+<span class="n">Connector</span> <span class="n">conn</span> <span
class="o">=</span> <span class="n">instance</span><span class="o">.</span><span
class="na">getConnector</span><span class="o">(</span><span class="s">"root"</span><span
class="o">,</span> <span class="k">new</span> <span class="n">PasswordToken</span><span
class="o">(</span><span class="s">"password"</span><span class="o">));</span>
+</code></pre>
+</div>
+
+<p>Upon completion of our development code, we will want to shutdown our MiniAccumuloCluster:</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">accumulo</span><span class="o">.</span><span class="na">stop</span><span
class="o">();</span>
+<span class="c1">// delete your temporary folder</span>
+</code></pre>
+</div>
 
 <h2 id="iterator-test-harness">Iterator Test Harness</h2>
 
@@ -333,15 +372,27 @@ for all Accumulo Iterators to leverage to identify common pitfalls in
user-creat
 
 <h3 id="framework-use">Framework Use</h3>
 
-<p>The harness provides an abstract class for use with JUnit4. Users must define the
following for this
-abstract class:</p>
+<p>The Iterator Test Harness is published in a separate jar that should be added to
your pom.xml as
+a test dependency:</p>
+
+<div class="language-xml highlighter-rouge"><pre class="highlight"><code><span
class="nt">&lt;dependency&gt;</span>
+  <span class="nt">&lt;groupId&gt;</span>org.apache.accumulo<span
class="nt">&lt;/groupId&gt;</span>
+  <span class="nt">&lt;artifactId&gt;</span>accumulo-iterator-test-harness<span
class="nt">&lt;/artifactId&gt;</span>
+  <span class="nt">&lt;version&gt;</span>${accumulo.version}<span
class="nt">&lt;/version&gt;</span>
+  <span class="nt">&lt;scope&gt;</span>test<span class="nt">&lt;/scope&gt;</span>
+<span class="nt">&lt;/dependency&gt;</span>
+</code></pre>
+</div>
+
+<p>To use the Iterator test harness, create a class that extends the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-iterator-test-harness/1.8.1/org/apache/accumulo/iteratortest/junit4/BaseJUnit4IteratorTest.html">BaseJUnit4IteratorTest</a>
class
+and defines the following:</p>
 
 <ul>
   <li>A <code class="highlighter-rouge">SortedMap</code> of input data
(<code class="highlighter-rouge">Key</code>-<code class="highlighter-rouge">Value</code>
pairs)</li>
-  <li>A <code class="highlighter-rouge">Range</code> to use in tests</li>
+  <li>A <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Range.html">Range</a>
to use in tests</li>
   <li>A <code class="highlighter-rouge">Map</code> of options (<code
class="highlighter-rouge">String</code> to <code class="highlighter-rouge">String</code>
pairs)</li>
   <li>A <code class="highlighter-rouge">SortedMap</code> of output data
(<code class="highlighter-rouge">Key</code>-<code class="highlighter-rouge">Value</code>
pairs)</li>
-  <li>A list of <code class="highlighter-rouge">IteratorTestCase</code>s
(these can be automatically discovered)</li>
+  <li>A list of <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-iterator-test-harness/1.8.1/org/apache/accumulo/iteratortest/testcases/IteratorTestCase.html">IteratorTestCase</a>s
(these can be automatically discovered)</li>
 </ul>
 
 <p>The majority of effort a user must make is in creating the input dataset and the
expected
@@ -409,7 +460,7 @@ output dataset for the iterator being tested.</p>
 
 <h3 id="limitations">Limitations</h3>
 
-<p>While the provided <code class="highlighter-rouge">IteratorTestCase</code>s
should exercise common edge-cases in user iterators,
+<p>While the provided <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-iterator-test-harness/1.8.1/org/apache/accumulo/iteratortest/testcases/IteratorTestCase.html">IteratorTestCase</a>s
should exercise common edge-cases in user iterators,
 there are still many limitations to the existing test harness. Some of them are:</p>
 
 <ul>
@@ -420,97 +471,6 @@ there are still many limitations to the existing test harness. Some of
them are:
 
 <p>These are left as future improvements to the harness.</p>
 
-<h2 id="mock-accumulo">Mock Accumulo</h2>
-
-<p>Mock Accumulo supplies mock implementations for much of the client API. It presently
-does not enforce users, logins, permissions, etc. It does support Iterators and Combiners.
-Note that MockAccumulo holds all data in memory, and will not retain any data or
-settings between runs.</p>
-
-<p>While normal interaction with the Accumulo client looks like this:</p>
-
-<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">Instance</span> <span class="n">instance</span> <span class="o">=</span>
<span class="k">new</span> <span class="n">ZooKeeperInstance</span><span
class="o">(...);</span>
-<span class="n">Connector</span> <span class="n">conn</span> <span
class="o">=</span> <span class="n">instance</span><span class="o">.</span><span
class="na">getConnector</span><span class="o">(</span><span class="n">user</span><span
class="o">,</span> <span class="n">passwordToken</span><span class="o">);</span>
-</code></pre>
-</div>
-
-<p>To interact with the MockAccumulo, just replace the ZooKeeperInstance with MockInstance:</p>
-
-<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">Instance</span> <span class="n">instance</span> <span class="o">=</span>
<span class="k">new</span> <span class="n">MockInstance</span><span
class="o">();</span>
-</code></pre>
-</div>
-
-<p>In fact, you can use the <code class="highlighter-rouge">--fake</code>
option to the Accumulo shell and interact with
-MockAccumulo:</p>
-
-<div class="highlighter-rouge"><pre class="highlight"><code>$ accumulo
shell --fake -u root -p ''
-
-Shell - Apache Accumulo Interactive Shell
--
-- version: 2.x.x
-- instance name: fake
-- instance id: mock-instance-id
--
-- type 'help' for a list of available commands
--
-
-root@fake&gt; createtable test
-
-root@fake test&gt; insert row1 cf cq value
-root@fake test&gt; insert row2 cf cq value2
-root@fake test&gt; insert row3 cf cq value3
-
-root@fake test&gt; scan
-row1 cf:cq []    value
-row2 cf:cq []    value2
-row3 cf:cq []    value3
-
-root@fake test&gt; scan -b row2 -e row2
-row2 cf:cq []    value2
-
-root@fake test&gt;
-</code></pre>
-</div>
-
-<p>When testing Map Reduce jobs, you can also set the Mock Accumulo on the AccumuloInputFormat
-and AccumuloOutputFormat classes:</p>
-
-<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="c1">// ... set up job configuration</span>
-<span class="n">AccumuloInputFormat</span><span class="o">.</span><span
class="na">setMockInstance</span><span class="o">(</span><span class="n">job</span><span
class="o">,</span> <span class="s">"mockInstance"</span><span class="o">);</span>
-<span class="n">AccumuloOutputFormat</span><span class="o">.</span><span
class="na">setMockInstance</span><span class="o">(</span><span class="n">job</span><span
class="o">,</span> <span class="s">"mockInstance"</span><span class="o">);</span>
-</code></pre>
-</div>
-
-<h2 id="mini-accumulo-cluster">Mini Accumulo Cluster</h2>
-
-<p>While the Mock Accumulo provides a lightweight implementation of the client API
for unit
-testing, it is often necessary to write more realistic end-to-end integration tests that
-take advantage of the entire ecosystem. The Mini Accumulo Cluster makes this possible by
-configuring and starting Zookeeper, initializing Accumulo, and starting the Master as well
-as some Tablet Servers. It runs against the local filesystem instead of having to start
-up HDFS.</p>
-
-<p>To start it up, you will need to supply an empty directory and a root password as
arguments:</p>
-
-<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">File</span> <span class="n">tempDirectory</span> <span class="o">=</span>
<span class="c1">// JUnit and Guava supply mechanisms for creating temp directories</span>
-<span class="n">MiniAccumuloCluster</span> <span class="n">accumulo</span>
<span class="o">=</span> <span class="k">new</span> <span class="n">MiniAccumuloCluster</span><span
class="o">(</span><span class="n">tempDirectory</span><span class="o">,</span>
<span class="s">"password"</span><span class="o">);</span>
-<span class="n">accumulo</span><span class="o">.</span><span class="na">start</span><span
class="o">();</span>
-</code></pre>
-</div>
-
-<p>Once we have our mini cluster running, we will want to interact with the Accumulo
client API:</p>
-
-<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">Instance</span> <span class="n">instance</span> <span class="o">=</span>
<span class="k">new</span> <span class="n">ZooKeeperInstance</span><span
class="o">(</span><span class="n">accumulo</span><span class="o">.</span><span
class="na">getInstanceName</span><span class="o">(),</span> <span
class="n">accumulo</span><span class="o">.</span><span class="na">getZooKeepers</span><span
class="o">());</span>
-<span class="n">Connector</span> <span class="n">conn</span> <span
class="o">=</span> <span class="n">instance</span><span class="o">.</span><span
class="na">getConnector</span><span class="o">(</span><span class="s">"root"</span><span
class="o">,</span> <span class="k">new</span> <span class="n">PasswordToken</span><span
class="o">(</span><span class="s">"password"</span><span class="o">));</span>
-</code></pre>
-</div>
-
-<p>Upon completion of our development code, we will want to shutdown our MiniAccumuloCluster:</p>
-
-<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">accumulo</span><span class="o">.</span><span class="na">stop</span><span
class="o">();</span>
-<span class="c1">// delete your temporary folder</span>
-</code></pre>
-</div>
 
   </div>
 </div>

http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/41adefb6/docs/unreleased/development/high_speed_ingest.html
----------------------------------------------------------------------
diff --git a/docs/unreleased/development/high_speed_ingest.html b/docs/unreleased/development/high_speed_ingest.html
index 7cc143b..4472d79 100644
--- a/docs/unreleased/development/high_speed_ingest.html
+++ b/docs/unreleased/development/high_speed_ingest.html
@@ -347,7 +347,7 @@ rate is still subject to the number of machines running ingest clients,
and the
 distribution of rowIDs across the table. The aggregation ingest rate will be
 suboptimal if there are many inserts into a small number of rowIDs.</p>
 
-<h2 id="multiple-ingester-clients">Multiple Ingester Clients</h2>
+<h2 id="multiple-ingest-clients">Multiple Ingest Clients</h2>
 
 <p>Accumulo is capable of scaling to very high rates of ingest, which is dependent
upon
 not just the number of TabletServers in operation but also the number of ingest
@@ -388,7 +388,7 @@ zz
 </code></pre>
 </div>
 
-<p>Run the MapReduce job, using the AccumuloFileOutputFormat to create the files to
+<p>Run the MapReduce job, using the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/mapred/AccumuloFileOutputFormat.html">AccumuloFileOutputFormat</a>
to create the files to
 be introduced to Accumulo. Once this is complete, the files can be added to
 Accumulo via the shell:</p>
 
@@ -400,8 +400,7 @@ Accumulo via the shell:</p>
 which Accumulo is running. Accumulo places any files that failed to be added to the
 second directory specified.</p>
 
-<p>See the <a href="https://github.com/apache/accumulo-examples/blob/master/docs/bulkIngest.md">bulk
ingest example</a>
-for a complete example.</p>
+<p>See the <a href="https://github.com/apache/accumulo-examples/blob/master/docs/bulkIngest.md">bulk
ingest example</a> for a complete example.</p>
 
 <h2 id="logical-time-for-bulk-ingest">Logical Time for Bulk Ingest</h2>
 
@@ -426,10 +425,11 @@ import file.</p>
 <h2 id="mapreduce-ingest">MapReduce Ingest</h2>
 
 <p>It is possible to efficiently write many mutations to Accumulo in parallel via a
-MapReduce job. In this scenario the MapReduce is written to process data that lives
-in HDFS and write mutations to Accumulo using the AccumuloOutputFormat. See
-the MapReduce section under Analytics for details. The <a href="https://github.com/apache/accumulo-examples/blob/master/docs/mapred.md">MapReduce
example</a>
-is also a good reference for example code.</p>
+MapReduce job.  Typically, a MapReduce job will process data that lives in HDFS
+and write mutations to Accumulo using <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/mapred/AccumuloOutputFormat.html">AccumuloOutputFormat</a>.
For more information
+on how use to use MapReduce with Accumulo, see the <a href="/docs/unreleased/development/mapreduce">MapReduce
documentation</a>
+and the <a href="https://github.com/apache/accumulo-examples/blob/master/docs/mapred.md">MapReduce
example code</a>.</p>
+
 
   </div>
 </div>

http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/41adefb6/docs/unreleased/development/security.html
----------------------------------------------------------------------
diff --git a/docs/unreleased/development/security.html b/docs/unreleased/development/security.html
index d5cfcfc..ed82703 100644
--- a/docs/unreleased/development/security.html
+++ b/docs/unreleased/development/security.html
@@ -318,7 +318,7 @@
     <h1>Security</h1>
     
     <p>Accumulo extends the BigTable data model to implement a security mechanism
-known as cell-level security. Every key-value pair has its own security label, stored
+known as cell-level security. Every <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Key.html">Key</a>-<a
href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Value.html">Value</a>
pair has its own security label, stored
 under the column visibility element of the key, which is used to determine whether
 a given user meets the security requirements to read the value. This enables data of
 various security levels to be stored within the same row, and users of varying
@@ -327,7 +327,7 @@ degrees of access to query the same table, while preserving data confidentiality
 <h2 id="security-label-expressions">Security Label Expressions</h2>
 
 <p>When mutations are applied, users can specify a security label for each value. This
is
-done as the Mutation is created by passing a ColumnVisibility object to the put()
+done as the <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/data/Mutation.html">Mutation</a>
is created by passing a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/security/ColumnVisibility.html">ColumnVisibility</a>
object to the put()
 method:</p>
 
 <div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">Text</span> <span class="n">rowID</span> <span class="o">=</span>
<span class="k">new</span> <span class="n">Text</span><span class="o">(</span><span
class="s">"row1"</span><span class="o">);</span>
@@ -384,18 +384,18 @@ admin|audit
 <p>When both <code class="highlighter-rouge">|</code> and <code class="highlighter-rouge">&amp;</code>
operators are used, parentheses must be used to specify
 precedence of the operators.</p>
 
-<h2 id="authorization">Authorization</h2>
+<h2 id="authorizations">Authorizations</h2>
 
 <p>When clients attempt to read data from Accumulo, any security labels present are
-examined against the set of authorizations passed by the client code when the
-Scanner or BatchScanner are created. If the authorizations are determined to be
+examined against an <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/security/Authorizations.html">Authorizations</a>
object passed by the client code when the
+<a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/Scanner.html">Scanner</a>
or <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/BatchScanner.html">BatchScanner</a>
are created. If the Authorizations are determined to be
 insufficient to satisfy the security label, the value is suppressed from the set of
 results sent back to the client.</p>
 
-<p>Authorizations are specified as a comma-separated list of tokens the user possesses:</p>
+<p><a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/security/Authorizations.html">Authorizations</a>
are specified as a comma-separated list of tokens the user possesses:</p>
 
 <div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="c1">// user possesses both admin and system level access</span>
-<span class="n">Authorization</span> <span class="n">auths</span>
<span class="o">=</span> <span class="k">new</span> <span class="n">Authorization</span><span
class="o">(</span><span class="s">"admin"</span><span class="o">,</span><span
class="s">"system"</span><span class="o">);</span>
+<span class="n">Authorizations</span> <span class="n">auths</span>
<span class="o">=</span> <span class="k">new</span> <span class="n">Authorizations</span><span
class="o">(</span><span class="s">"admin"</span><span class="o">,</span><span
class="s">"system"</span><span class="o">);</span>
 
 <span class="n">Scanner</span> <span class="n">s</span> <span
class="o">=</span> <span class="n">connector</span><span class="o">.</span><span
class="na">createScanner</span><span class="o">(</span><span class="s">"table"</span><span
class="o">,</span> <span class="n">auths</span><span class="o">);</span>
 </code></pre>
@@ -403,17 +403,18 @@ results sent back to the client.</p>
 
 <h2 id="user-authorizations">User Authorizations</h2>
 
-<p>Each Accumulo user has a set of associated security labels. To manipulate
-these in the shell while using the default authorizor, use the setuaths and getauths commands.
-These may also be modified for the default authorizor using the java security operations
API.</p>
+<p>Each Accumulo user has a set of associated security labels. To manipulate these
in
+the <a href="/docs/unreleased/getting-started/shell">Accumulo shell</a>, use
the <code class="highlighter-rouge">setuaths</code> and <code class="highlighter-rouge">getauths</code>
commands. They can be
+retrieved and modified in Java using <code class="highlighter-rouge">getUserAuthorizations</code>
and <code class="highlighter-rouge">changeUserAuthorizations</code>
+methods of <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/admin/SecurityOperations.html">SecurityOperations</a>.</p>
 
-<p>When a user creates a scanner a set of Authorizations is passed. If the
-authorizations passed to the scanner are not a subset of the users
-authorizations, then an exception will be thrown.</p>
+<p>When a user creates a <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/Scanner.html">Scanner</a>
or <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/BatchScanner.html">BatchScanner</a>
a set of <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/security/Authorizations.html">Authorizations</a>
is passed.
+If the Authorizations passed to the scanner are not a subset of the user’s Authorizations,
+then an exception will be thrown.</p>
 
 <p>To prevent users from writing data they can not read, add the visibility
-constraint to a table. Use the -evc option in the createtable shell command to
-enable this constraint. For existing tables use the following shell command to
+constraint to a table. Use the -evc option in the <code class="highlighter-rouge">createtable</code>
shell command to
+enable this constraint. For existing tables, use the <code class="highlighter-rouge">config</code>
command to
 enable the visibility constraint. Ensure the constraint number does not
 conflict with any existing constraints.</p>
 
@@ -427,18 +428,19 @@ disable the bulk import permission.</p>
 
 <h2 id="pluggable-security">Pluggable Security</h2>
 
-<p>New in 1.5 of Accumulo is a pluggable security mechanism. It can be broken into
three actions –
-authentication, authorization, and permission handling. By default all of these are handled
in
-Zookeeper, which is how things were handled in Accumulo 1.4 and before. It is worth noting
at this
-point, that it is a new feature in 1.5 and may be adjusted in future releases without the
standard
-deprecation cycle.</p>
+<p>Accumulo has a pluggable security mechanism. It can be broken into three actions:
authentication, 
+authorization, and permission handling.</p>
 
-<p>Authentication simply handles the ability for a user to verify their integrity.
A combination of
-principal and authentication token are used to verify a user is who they say they are. An
-authentication token should be constructed, either directly through its constructor, but
it is
-advised to use the <code class="highlighter-rouge">init(Property)</code> method
to populate an authentication token. It is expected that a
-user knows what the appropriate token to use for their system is. The default token is
-<code class="highlighter-rouge">PasswordToken</code>.</p>
+<p>Authentication verifies the identity of a user. In Accumulo, authentication occurs
when
+the <code class="highlighter-rouge">getConnector</code> method of <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/Instance.html">Instance</a>
is called with a principal (i.e username)
+and an <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/security/tokens/AuthenticationToken.html">AuthenticationToken</a>
which is an interface with multiple implementations. The most
+common implementation is <a href="https://static.javadoc.io/org.apache.accumulo/accumulo-core/1.8.1/org/apache/accumulo/core/client/security/tokens/PasswordToken.html">PasswordToken</a>
which is the default authenticaton method for Accumulo
+out of the box.</p>
+
+<div class="language-java highlighter-rouge"><pre class="highlight"><code><span
class="n">Instance</span> <span class="n">instance</span> <span class="o">=</span>
<span class="k">new</span> <span class="n">ZooKeeperInstance</span><span
class="o">(</span><span class="s">"myinstance"</span><span class="o">,</span>
<span class="s">"zookeeper1,zookeeper2"</span><span class="o">);</span>
+<span class="n">Connector</span> <span class="n">conn</span> <span
class="o">=</span> <span class="n">instance</span><span class="o">.</span><span
class="na">getConnector</span><span class="o">(</span><span class="s">"user"</span><span
class="o">,</span> <span class="k">new</span> <span class="n">PasswordToken</span><span
class="o">(</span><span class="s">"passwd"</span><span class="o">));</span>
+</code></pre>
+</div>
 
 <p>Once a user is authenticated by the Authenticator, the user has access to the other
actions within
 Accumulo. All actions in Accumulo are ACLed, and this ACL check is handled by the Permission
@@ -485,6 +487,7 @@ Authorizations mechanism.</p>
 
 <p>Typically, the query services layer sits between Accumulo and user workstations.</p>
 
+
   </div>
 </div>
 

http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/41adefb6/docs/unreleased/getting-started/shell.html
----------------------------------------------------------------------
diff --git a/docs/unreleased/getting-started/shell.html b/docs/unreleased/getting-started/shell.html
index 2981382..42263d7 100644
--- a/docs/unreleased/getting-started/shell.html
+++ b/docs/unreleased/getting-started/shell.html
@@ -344,36 +344,33 @@ root@myinstance&gt;
 
 <h2 id="basic-administration">Basic Administration</h2>
 
-<p>The Accumulo shell can be used to create and delete tables, as well as to configure
-table and instance specific options.</p>
+<p>The <code class="highlighter-rouge">tables</code> command will list
all existings tables.</p>
 
 <div class="highlighter-rouge"><pre class="highlight"><code>root@myinstance&gt;
tables
 accumulo.metadata
 accumulo.root
+</code></pre>
+</div>
 
-root@myinstance&gt; createtable mytable
-
-root@myinstance mytable&gt;
+<p>The <code class="highlighter-rouge">createtable</code> command creates
a new table.</p>
 
+<div class="highlighter-rouge"><pre class="highlight"><code>root@myinstance&gt;
createtable mytable
 root@myinstance mytable&gt; tables
 accumulo.metadata
 accumulo.root
 mytable
+</code></pre>
+</div>
 
-root@myinstance mytable&gt; createtable testtable
-
-root@myinstance testtable&gt;
+<p>The <code class="highlighter-rouge">deletetable</code> command deletes
a table.</p>
 
-root@myinstance testtable&gt; deletetable testtable
+<div class="highlighter-rouge"><pre class="highlight"><code>root@myinstance
testtable&gt; deletetable testtable
 deletetable { testtable } (yes|no)? yes
 Table: [testtable] has been deleted.
-
-root@myinstance&gt;
 </code></pre>
 </div>
 
-<p>The Shell can also be used to insert updates and scan tables. This is useful for
-inspecting tables.</p>
+<p>The shell can be used to insert updates and scan tables. This is useful for inspecting
tables.</p>
 
 <div class="highlighter-rouge"><pre class="highlight"><code>root@myinstance
mytable&gt; scan
 
@@ -390,7 +387,7 @@ You can use the <code class="highlighter-rouge">-st</code>
option to scan to see
 
 <h2 id="table-maintenance">Table Maintenance</h2>
 
-<p>The <em>compact</em> command instructs Accumulo to schedule a compaction
of the table during which
+<p>The <code class="highlighter-rouge">compact</code> command instructs
Accumulo to schedule a compaction of the table during which
 files are consolidated and deleted entries are removed.</p>
 
 <div class="highlighter-rouge"><pre class="highlight"><code>root@myinstance
mytable&gt; compact -t mytable
@@ -398,7 +395,7 @@ files are consolidated and deleted entries are removed.</p>
 </code></pre>
 </div>
 
-<p>The <em>flush</em> command instructs Accumulo to write all entries currently
in memory for a given table
+<p>The <code class="highlighter-rouge">flush</code> command instructs Accumulo
to write all entries currently in memory for a given table
 to disk.</p>
 
 <div class="highlighter-rouge"><pre class="highlight"><code>root@myinstance
mytable&gt; flush -t mytable
@@ -440,35 +437,6 @@ root@myinstance bobstable&gt; revoke System.CREATE_TABLE -s -u bob
 </code></pre>
 </div>
 
-<h2 id="jsr-223-support-in-the-shell">JSR-223 Support in the Shell</h2>
-
-<p>The script command can be used to invoke programs written in languages supported
by installed JSR-223
-engines. You can get a list of installed engines with the -l argument. Below is an example
of the output
-of the command when running the Shell with Java 7.</p>
-
-<div class="highlighter-rouge"><pre class="highlight"><code>root@fake&gt;
script -l
-    Engine Alias: ECMAScript
-    Engine Alias: JavaScript
-    Engine Alias: ecmascript
-    Engine Alias: javascript
-    Engine Alias: js
-    Engine Alias: rhino
-    Language: ECMAScript (1.8)
-    Script Engine: Mozilla Rhino (1.7 release 3 PRERELEASE)
-ScriptEngineFactory Info
-</code></pre>
-</div>
-
-<p>A list of compatible languages can be found on <a href="https://en.wikipedia.org/wiki/List_of_JVM_languages">this
page</a>. The
-rhino javascript engine is provided with the JVM. Typically putting a jar on the classpath
is all that is
-needed to install a new engine.</p>
-
-<p>When writing scripts to run in the shell, you will have a variable called connection
already available
-to you. This variable is a reference to an Accumulo Connector object, the same connection
that the Shell
-is using to communicate with the Accumulo servers. At this point you can use any of the public
API methods
-within your script. Reference the script command help to see all of the execution options.
Script and script
-invocation examples can be found in ACCUMULO-1399.</p>
-
   </div>
 </div>
 

http://git-wip-us.apache.org/repos/asf/accumulo-website/blob/41adefb6/feed.xml
----------------------------------------------------------------------
diff --git a/feed.xml b/feed.xml
index 81ee302..1beb4f1 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>Tue, 30 May 2017 11:36:53 -0400</pubDate>
-    <lastBuildDate>Tue, 30 May 2017 11:36:53 -0400</lastBuildDate>
+    <pubDate>Wed, 31 May 2017 14:32:53 -0400</pubDate>
+    <lastBuildDate>Wed, 31 May 2017 14:32:53 -0400</lastBuildDate>
     <generator>Jekyll v3.3.1</generator>
     
       <item>


Mime
View raw message