This is an automated email from the ASF dual-hosted git repository.
git-site-role pushed a commit to branch asf-staging
in repository https://gitbox.apache.org/repos/asf/fluo-website.git
The following commit(s) were added to refs/heads/asf-staging by this push:
new bf614f8 Automatic Site Publish by Buildbot
bf614f8 is described below
commit bf614f83b16e554421373a45a6b5abfbf18b128f
Author: buildbot <[email protected]>
AuthorDate: Wed Oct 11 20:04:33 2023 +0000
Automatic Site Publish by Buildbot
---
output/feed.xml | 260 +++++++-------------------
output/index.html | 10 +-
output/news/index.html | 11 ++
output/{releases => release/2.0.0}/index.html | 114 ++++++-----
output/releases/index.html | 9 +
output/search_data.json | 8 +
6 files changed, 154 insertions(+), 258 deletions(-)
diff --git a/output/feed.xml b/output/feed.xml
index 208709a..c69956e 100644
--- a/output/feed.xml
+++ b/output/feed.xml
@@ -5,11 +5,75 @@
<description>Apache Fluo Website</description>
<link>https://fluo.apache.org//</link>
<atom:link href="https://fluo.apache.org//feed.xml"; rel="self"
type="application/rss+xml" />
- <pubDate>Thu, 18 May 2023 14:22:22 +0000</pubDate>
- <lastBuildDate>Thu, 18 May 2023 14:22:22 +0000</lastBuildDate>
+ <pubDate>Wed, 11 Oct 2023 20:04:31 +0000</pubDate>
+ <lastBuildDate>Wed, 11 Oct 2023 20:04:31 +0000</lastBuildDate>
<generator>Jekyll v4.2.0</generator>
+ <item>
+ <title>Apache Fluo 2.0.0</title>
+ <description><p>Apache Fluo is a distributed processing system
that lets users make incremental
+updates to large data sets. With Apache Fluo, users can set up workflows that
+execute cross node transactions when data changes. These workflows enable users
+to continuously join new data into large existing data sets without
+reprocessing all data. Apache Fluo is built on [Apache Accumulo].</p>
+
+<p>Below are resources for this release:</p>
+
+<ul>
+ <li>
+ <p>Download a release tarball and verify by these [procedures] using
these [KEYS]</p>
+
+ <table>
+ <tbody>
+ <tr>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-bin.tar.gz">fluo-2.0.0-bin.tar.gz</a></td>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-bin.tar.gz.asc">ASC</a>
<a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-bin.tar.gz.sha512">SHA</a></td>
+ </tr>
+ <tr>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-source-release.tar.gz">fluo-2.0.0-source-release.tar.gz</a></td>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-source-release.tar.gz.asc">ASC</a>
<a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-source-release.tar.gz.sha512">SHA</a></td>
+ </tr>
+ </tbody>
+ </table>
+ </li>
+ <li>
+ <p>Read the <a
href="https://javadoc.io/doc/org.apache.fluo/fluo-api/2.0.0/index.html">Javadocs</a>.</p>
+ </li>
+</ul>
+
+<p>Apache Fluo follows <a
href="http://semver.org/">semver</a> for its API . The API
consists
+of everything under the <code class="language-plaintext
highlighter-rouge">org.apache.fluo.api</code> package. Code
outside of this
+package can change at any time. If your project is using Fluo code that falls
+outside of the API, then consider <a
href="/getinvolved/">initiating a discussion</a>
+about adding it to the API.</p>
+
+<h2 id="notable-changes">Notable changes</h2>
+
+<p>The major changes in 2.0.0 are highlighted here, for the complete
list of changes, see the <a
href="https://github.com/apache/fluo/milestone/8?closed=1">2.0.0
+Milestone</a> on Github.</p>
+
+<ul>
+ <li>Many performance and bug fixes were made.</li>
+ <li>Fluo was updated to work with Accumulo 2.1.0, Java 11, and Hadoop
3</li>
+ <li>Added scan authorizations to snapshots <a
href="https://github.com/apache/fluo/pull/1120">1120</a></li>
+ <li>Added asynchronous get methods to snapshots for reading data.
<a
href="https://github.com/apache/fluo/pull/969">969</a></li>
+ <li>Added asynchronous submit method to LoaderExecutor <a
href="https://github.com/apache/fluo/pull/1113">1100</a></li>
+ <li>Added option to Fluo’s scan command to show notifications. <a
href="https://github.com/apache/fluo/issues/1026">1026</a></li>
+ <li>Fluo now sets Accumulo scan hints. This can be used to optimize
Fluo server side scan execution in Accumulo. <a
href="https://github.com/apache/fluo/pull/1072">1072</a></li>
+ <li>Summaries of Fluo’s metadata are generated in Accumulo. This could
be used to select files for compaction in Accumulo. <a
href="https://github.com/apache/fluo/pull/1071">1071</a></li>
+</ul>
+
+</description>
+ <pubDate>Tue, 18 Apr 2023 15:00:00 +0000</pubDate>
+ <link>https://fluo.apache.org//release/2.0.0/</link>
+ <guid isPermaLink="true">https://fluo.apache.org//release/2.0.0/</guid>
+
+
+ <category>release</category>
+
+ </item>
+
<item>
<title>How Fluo Leveraged Scan Executors</title>
<description><p>Accumulo 2.0 introduced <a
href="https://accumulo.apache.org/docs/2.x/administration/scan-executors">Scan
Executors</a> giving control over processing of
@@ -1078,198 +1142,6 @@ implications of early vs late binding is something to
consider.</p>
<guid
isPermaLink="true">https://fluo.apache.org//blog/2016/12/22/spark-load/</guid>
- <category>blog</category>
-
- </item>
-
- <item>
- <title>Java needs an immutable byte string</title>
- <description><h2
id="fluo-data-model-and-transactions">Fluo Data Model and
Transactions</h2>
-
-<p>Fluo uses a <a href="/tour/data-model/">data
model</a> composed of key/values. Each key has four fields :
-<em>row</em>,<em>family</em>,<em>qualifier</em>,<em>visibility</em>.
Each of these key fields is a sequence of bytes. Fluo
-transactions read key/values from a snapshot of a table. Any changes a
transaction makes is
-buffered until commit. At the time of commit the changes are only made if no
other transaction
-modified any of the key values.</p>
-
-<p>While designing the Fluo API we were uncertain about making Fluo’s
basic <a href="/tour/data-pojos/">POJOs</a> mutable or
-immutable. In the end we decided to go with immutable types to make writing
correct Fluo code
-easier. One of the POJOs we created was <a
href="https://javadoc.io/page/org.apache.fluo/fluo-api/1.2.0/org/apache/fluo/api/data/Bytes.html">Bytes</a>,
an immutable wrapper around a byte array. We
-also created <a
href="https://javadoc.io/page/org.apache.fluo/fluo-api/1.2.0/org/apache/fluo/api/data/Bytes.BytesBuilder.html">BytesBuilder</a>,
which is analogous to StringBuilder, and makes it easy and efficient
-to construct Bytes.</p>
-
-<h3 id="what-about-the-copies">What about the
copies?</h3>
-
-<p>Bytes requires a defensive copy at creation time. When we were
designing Fluo’s API we were worried
-about this at first. However a simple truth became apparent. If the API took
a mutable type, then
-all boundary points between the user and Fluo would require defensive copies.
For example assume
-Fluo’s API took byte arrays and consider the following code.</p>
-
-<div class="language-java highlighter-rouge"><div
class="highlight"><pre
class="highlight"><code><span class="c1">//A
Fluo transaction</span>
-<span class="nc">Transaction</span> <span
class="n">tx</span> <span
class="o">=</span> <span
class="o">...</span>
-<span class="kt">byte</span><span
class="o">[]</span> <span
class="n">row</span> <span
class="o">=</span> <span
class="o">...</span>
-
-<span class="n">tx</span><span
class="o">.</span><span
class="na">set</span><span
class="o">(</span><span
class="n">row</span><span
class="o">,</span> <span
class="n">column1</span><span
class="o">,</span> <span
class="n">value1</span><span
class="o">);</span>
-<span class="n">tx</span><span
class="o">.</span><span
class="na">set</span><span
class="o">(</span><span
class="n">row</span><span
class="o">,</span> <span
class="n">column2</span><span
class="o">,</span> <span
class="n">value2</span><span
class="o">);</span>
-<span class="n">tx</span><span
class="o">.</span><span
class="na">set</span><span
class="o">(</span><span
class="n">row</span><span
class="o">,</span> <span
class="n">column3</span><span
class="o">,</span> <span
class="n">value3</span><span
class="o">);</span>
-</code></pre></div></div>
-
-<p>Fluo will buffer changes until a transaction is committed. In the
example above since Fluo accepts
-a mutable row, it would be prudent to do a defensive copy each time <code
class="language-plaintext highlighter-rouge">set()</code> is
called above.</p>
-
-<p>In the code below where an immutable byte array wrapper is used, the
calls to <code class="language-plaintext
highlighter-rouge">set()</code> do not need to
-do a defensive copy. So when comparing the two examples, the immutable byte
wrapper results in less
-defensive copies.</p>
-
-<div class="language-java highlighter-rouge"><div
class="highlight"><pre
class="highlight"><code><span class="c1">//A
Fluo transaction</span>
-<span class="nc">Transaction</span> <span
class="n">tx</span> <span
class="o">=</span> <span
class="o">...</span>
-<span class="nc">Bytes</span> <span
class="n">row</span> <span
class="o">=</span> <span
class="o">...</span>
-
-<span class="n">tx</span><span
class="o">.</span><span
class="na">set</span><span
class="o">(</span><span
class="n">row</span><span
class="o">,</span> <span
class="n">column1</span><span
class="o">,</span> <span
class="n">value1</span><span
class="o">);</span>
-<span class="n">tx</span><span
class="o">.</span><span
class="na">set</span><span
class="o">(</span><span
class="n">row</span><span
class="o">,</span> <span
class="n">column2</span><span
class="o">,</span> <span
class="n">value2</span><span
class="o">);</span>
-<span class="n">tx</span><span
class="o">.</span><span
class="na">set</span><span
class="o">(</span><span
class="n">row</span><span
class="o">,</span> <span
class="n">column3</span><span
class="o">,</span> <span
class="n">value3</span><span
class="o">);</span>
-</code></pre></div></div>
-
-<p>We really did not want to create Bytes and BytesBuilder types,
however we could not find what we
-needed in Java’s standard libraries. The following sections discuss some of
the options we
-considered.</p>
-
-<h2 id="why-not-use-string">Why not use String?</h2>
-
-<p>Java’s String type is an immutable wrapper around a char array. In
order to store a byte array in a
-String, Java must decode the byte array using a character set. Some sequences
of bytes do not map
-in some characters sets. Therefore, trying to stuff arbitrary binary data in
a String can corrupt
-the data. The following little program shows this, it will print <code
class="language-plaintext
highlighter-rouge">false</code>.</p>
-
-<div class="language-java highlighter-rouge"><div
class="highlight"><pre
class="highlight"><code> <span
class="kt">byte</span> <span
class="n">bytes1</span><span
class="o">[]</span> <span
class="o">=</span> <span
class="k">new</span> <span
class="kt">byte</span><span
class="o">[</spa [...]
- <span class="k">for</span><span
class="o">(</span><span
class="kt">int</span> <span
class="n">i</span> <span
class="o">=</span> <span
class="mi">0</span><span
class="o">;</span> <span
class="n">i</span><span
class="o">&lt;</span><span
class="mi">255</span><span [...]
- <span class="n">bytes1</span><span
class="o">[</span><span
class="n">i</span><span
class="o">]</span> <span
class="o">=</span> <span
class="o">(</span><span
class="kt">byte</span><span
class="o">)</span><span
class="n">i</span><span
class="o">;</span>
-
- <span class="kt">byte</span> <span
class="n">bytes2</span><span
class="o">[]</span> <span
class="o">=</span> <span
class="k">new</span> <span
class="nc">String</span><span
class="o">(</span><span
class="n">bytes1</span><span
class="o">).</span><span
class="na">getBytes</ [...]
-
- <span class="nc">System</span><span
class="o">.</span><span
class="na">out</span><span
class="o">.</span><span
class="na">println</span><span
class="o">(</span><span
class="nc">Arrays</span><span
class="o">.</span><span
class="na">equals</span><span
class="o">(</span> [...]
-</code></pre></div></div>
-
-<p>String can be made to work by specifying an appropriate character
set. The following program will
-print <code class="language-plaintext
highlighter-rouge">true</code>. However, this is error prone and
inefficient. It’s error prone in the case where the
-character set is wrong or omitted. It’s inefficient because it results in
copying from byte arrays
-to char arrays and visa versa. Also, char arrays use twice as much
memory.</p>
-
-<div class="language-java highlighter-rouge"><div
class="highlight"><pre
class="highlight"><code> <span
class="kt">byte</span> <span
class="n">bytes1</span><span
class="o">[]</span> <span
class="o">=</span> <span
class="k">new</span> <span
class="kt">byte</span><span
class="o">[</spa [...]
- <span class="k">for</span><span
class="o">(</span><span
class="kt">int</span> <span
class="n">i</span> <span
class="o">=</span> <span
class="mi">0</span><span
class="o">;</span> <span
class="n">i</span><span
class="o">&lt;</span><span
class="mi">255</span><span [...]
- <span class="n">bytes1</span><span
class="o">[</span><span
class="n">i</span><span
class="o">]</span> <span
class="o">=</span> <span
class="o">(</span><span
class="kt">byte</span><span
class="o">)</span><span
class="n">i</span><span
class="o">;</span>
-
- <span class="nc">String</span> <span
class="n">str</span> <span
class="o">=</span> <span
class="k">new</span> <span
class="nc">String</span><span
class="o">(</span><span
class="n">bytes1</span><span
class="o">,</span> <span
class="nc">StandardCharsets</span><span
class="o"> [...]
- <span class="kt">byte</span> <span
class="n">bytes2</span><span
class="o">[]</span> <span
class="o">=</span> <span
class="n">str</span><span
class="o">.</span><span
class="na">getBytes</span><span
class="o">(</span><span
class="nc">StandardCharsets</span><span
class="o">.&l [...]
-
- <span class="nc">System</span><span
class="o">.</span><span
class="na">out</span><span
class="o">.</span><span
class="na">println</span><span
class="o">(</span><span
class="nc">Arrays</span><span
class="o">.</span><span
class="na">equals</span><span
class="o">(</span> [...]
-</code></pre></div></div>
-
-<h2 id="why-not-use-bytebuffer">Why not use
ByteBuffer?</h2>
-
-<p>A read only ByteBuffer might seem like it would fit the bill of an
immutable byte array wrapper.
-However, the following program shows two ways that ByteBuffer falls short.
ByteBuffers are great
-for I/O, but it would not be prudent to use them when immutability is
desired.</p>
-
-<div class="language-java highlighter-rouge"><div
class="highlight"><pre
class="highlight"><code> <span
class="kt">byte</span><span
class="o">[]</span> <span
class="n">bytes1</span> <span
class="o">=</span> <span
class="k">new</span> <span
class="kt">byte</span><span
class="o">[]</sp [...]
- <span class="nc">ByteBuffer</span> <span
class="n">bb1</span> <span
class="o">=</span> <span
class="nc">ByteBuffer</span><span
class="o">.</span><span
class="na">wrap</span><span
class="o">(</span><span
class="n">bytes1</span><span
class="o">).</span><span class="na">asRead
[...]
-
- <span class="nc">System</span><span
class="o">.</span><span
class="na">out</span><span
class="o">.</span><span
class="na">println</span><span
class="o">(</span><span
class="n">bb1</span><span
class="o">.</span><span
class="na">hashCode</span><span
class="o">());</span>
- <span class="n">bytes1</span><span
class="o">[</span><span
class="mi">2</span><span
class="o">]=</span><span
class="mi">89</span><span
class="o">;</span>
- <span class="nc">System</span><span
class="o">.</span><span
class="na">out</span><span
class="o">.</span><span
class="na">println</span><span
class="o">(</span><span
class="n">bb1</span><span
class="o">.</span><span
class="na">hashCode</span><span
class="o">());</span>
- <span class="n">bb1</span><span
class="o">.</span><span
class="na">get</span><span
class="o">();</span>
- <span class="nc">System</span><span
class="o">.</span><span
class="na">out</span><span
class="o">.</span><span
class="na">println</span><span
class="o">(</span><span
class="n">bb1</span><span
class="o">.</span><span
class="na">hashCode</span><span
class="o">());</span>
-</code></pre></div></div>
-
-<p>The program above prints the following, which is less than ideal
:</p>
-
-<div class="language-plaintext highlighter-rouge"><div
class="highlight"><pre
class="highlight"><code>747721
-830367
-26786
-</code></pre></div></div>
-
-<p>This little program shows two things. First, the only guarantee we
are getting from
-<code class="language-plaintext
highlighter-rouge">asReadOnlyBuffer()</code> is that <code
class="language-plaintext highlighter-rouge">bb1</code> can
not be used to modify <code class="language-plaintext
highlighter-rouge">bytes1</code>. However, the originator of
-the read only buffer can still modify the wrapped byte array. Java’s String
and Fluo’s Bytes avoid
-this by always copying data into an internal private array that never
escapes.</p>
-
-<p>The second issue is that <code class="language-plaintext
highlighter-rouge">bb1</code> has a position and calling <code
class="language-plaintext
highlighter-rouge">bb1.get()</code> changes this position.
-Changing the position conceptually changes the contents of the ByteBuffer.
This is why <code class="language-plaintext
highlighter-rouge">hashCode()</code>
-returns something different after <code class="language-plaintext
highlighter-rouge">bb1.get()</code> is called. So even though
<code class="language-plaintext
highlighter-rouge">bb1</code> does not enable
-mutating <code class="language-plaintext
highlighter-rouge">bytes1</code>, <code
class="language-plaintext highlighter-rouge">bb1</code> is
itself mutable.</p>
-
-<h2 id="why-not-use-protobufs-bytestring">Why not use
Protobuf’s ByteString?</h2>
-
-<p><a
href="https://developers.google.com/protocol-buffers/">Protocol
Buffers</a> has a beautiful implementation of an immutable byte array
wrapper called
-<a
href="https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/ByteString">ByteString</a>.
I would encourage its use when possible. I discovered this jewel after Bytes
was
-implemented in Fluo. Using it was considered, however in Fluo’s case its not
really appropriate to
-use for two reasons. First, any library designer should try to minimize what
transitive dependencies
-they force on users. Internally Fluo does not currently use Protocol Buffers
in its implementation,
-so this would be a new dependency for Fluo users. The second reason is going
to require some
-background to explain.</p>
-
-<p>Technologies like <a
href="https://www.osgi.org">OSGI</a> and <a
href="http://openjdk.java.net/projects/jigsaw/">Jigsaw</a>
seek to modularize Java libraries and provide dependency
-isolation. Dependency isolation allows a user to use a library without having
to share a libraries
-dependencies. For example, consider the following hypothetical
scenario.</p>
-
-<ul>
- <li>Fluo’s implementation uses Protobuf version 2.5</li>
- <li>Fluo user code uses Protobuf version 1.8</li>
-</ul>
-
-<p>Without dependency isolation, the user must converge dependencies and
make their application and
-Fluo use the same version of Protobuf. Sometimes this works without issue,
but sometimes things
-will break because Protobuf dropped, changed, or added a method.</p>
-
-<p>With dependency isolation, Fluo’s implementation and Fluo user code
can easily use different versions
-of Protobuf. This is only true as long as Fluo’s API does not use Protobuf.
So, this is the second
-reason that Fluo should not use classes from Protobuf in its API. If Fluo
used Protobuf in its API
-then it forces the user to have to converge dependencies, even if they are
using OSGI or Jigsaw.</p>
-
-<h2 id="java-should-have-an-immutable-byte-array-wrapper">Java
should have an immutable byte array wrapper</h2>
-
-<p>So far, the following arguments have been presented:</p>
-
-<ul>
- <li>An immutable byte array wrapper is useful and needed.</li>
- <li>Java does not provide a good immutable byte array
wrapper.</li>
- <li>Using an immutable byte array wrapper from library X in library
Y’s API may be problematic.</li>
-</ul>
-
-<p>These arguments all point to the need for an immutable byte array
wrapper to exist in Java. This
-need could also be satisfied by a library outside of Java with some
restrictions. Assume a new
-library called Lib Immutable Byte Array Wrapper (libibaw) was created. In
order for libibaw to be
-used in other libraries APIs, it would need to promise the following.</p>
-
-<ul>
- <li>No dependencies other than Java.</li>
- <li>Backwards compatibility.</li>
-</ul>
-
-<p>The reason backwards compatibility is important is that it would make
dependency convergence super
-easy. The following situation shows this.</p>
-
-<ul>
- <li>Fluo uses libibaw 1.2 in its API</li>
- <li>Fluo user code uses libibaw 1.1.</li>
-</ul>
-
-<p>If libibaw promises backward compatibility, then all the user needs
to do is use version 1.2 of
-libibaw. With the promise of backwards compatibility, using version 1.2 will
not break the users
-code.</p>
-
-<p>Having a library would be nice, but having something in Java would
minimize copies. Outside
-of Java there will inevitably be multiple implementations and going between
them will require a
-copy. For example if a user uses Fluo and Protobuf they may be forced to copy
Fluo’s Bytes to
-Protobuf’s ByteString. If Protobuf and Fluo both used an immutable byte
sequence type from Java, this
-would not be needed.</p>
-
-</description>
- <pubDate>Thu, 10 Nov 2016 11:43:00 +0000</pubDate>
- <link>https://fluo.apache.org//blog/2016/11/10/immutable-bytes/</link>
- <guid
isPermaLink="true">https://fluo.apache.org//blog/2016/11/10/immutable-bytes/</guid>
-
-
<category>blog</category>
</item>
diff --git a/output/index.html b/output/index.html
index fd2516b..ce7bc1d 100644
--- a/output/index.html
+++ b/output/index.html
@@ -121,7 +121,7 @@
<div class="post-header-home">
<div class="row">
<div class="col-sm-12">
- <p><a href="/blog/2019/09/30/scan-executors/">How Fluo Leveraged
Scan Executors</a> <small class="text-muted">Sep 2019</small></p>
+ <p><a href="/release/2.0.0/">Apache Fluo 2.0.0</a> <small
class="text-muted">Apr 2023</small></p>
</div>
</div>
</div>
@@ -129,7 +129,7 @@
<div class="post-header-home">
<div class="row">
<div class="col-sm-12">
- <p><a href="/release/fluo-yarn-1.0.0/">Apache Fluo YARN
1.0.0</a> <small class="text-muted">Mar 2018</small></p>
+ <p><a href="/blog/2019/09/30/scan-executors/">How Fluo Leveraged
Scan Executors</a> <small class="text-muted">Sep 2019</small></p>
</div>
</div>
</div>
@@ -137,7 +137,7 @@
<div class="post-header-home">
<div class="row">
<div class="col-sm-12">
- <p><a href="/release/fluo-recipes-1.2.0/">Apache Fluo Recipes
1.2.0</a> <small class="text-muted">Mar 2018</small></p>
+ <p><a href="/release/fluo-yarn-1.0.0/">Apache Fluo YARN
1.0.0</a> <small class="text-muted">Mar 2018</small></p>
</div>
</div>
</div>
@@ -145,7 +145,7 @@
<div class="post-header-home">
<div class="row">
<div class="col-sm-12">
- <p><a href="/release/fluo-1.2.0/">Apache Fluo 1.2.0</a>
<small class="text-muted">Feb 2018</small></p>
+ <p><a href="/release/fluo-recipes-1.2.0/">Apache Fluo Recipes
1.2.0</a> <small class="text-muted">Mar 2018</small></p>
</div>
</div>
</div>
@@ -153,7 +153,7 @@
<div class="post-header-home">
<div class="row">
<div class="col-sm-12">
- <p><a
href="/blog/2017/07/26/fluo-graduates-from-apache-incubator/">Fluo graduates
from the Apache incubator!</a> <small class="text-muted">Jul
2017</small></p>
+ <p><a href="/release/fluo-1.2.0/">Apache Fluo 1.2.0</a>
<small class="text-muted">Feb 2018</small></p>
</div>
</div>
</div>
diff --git a/output/news/index.html b/output/news/index.html
index 0152cb3..bd19344 100644
--- a/output/news/index.html
+++ b/output/news/index.html
@@ -107,6 +107,17 @@
+ <hr>
+ <h3 class="archive-section-header">2023</h3>
+
+ <div class="row">
+ <div class="col-md-1"><p>Apr 18</div>
+ <div class="col-md-10"><p><a href="/release/2.0.0/"
class="post-title-archive">Apache Fluo 2.0.0</a></div>
+ </div>
+
+
+
+
<hr>
<h3 class="archive-section-header">2019</h3>
diff --git a/output/releases/index.html b/output/release/2.0.0/index.html
similarity index 62%
copy from output/releases/index.html
copy to output/release/2.0.0/index.html
index f1b6421..f9e3f5b 100644
--- a/output/releases/index.html
+++ b/output/release/2.0.0/index.html
@@ -8,10 +8,10 @@
<link
href="https://maxcdn.bootstrapcdn.com/bootswatch/3.3.7/cosmo/bootstrap.min.css";
rel="stylesheet"
integrity="sha384-h21C2fcDk/eFsW9sC9h0dhokq5pDinLNklTKoxIZRUn3+hvmgQSffLLQ4G4l2eEr"
crossorigin="anonymous">
<link
href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css";
rel="stylesheet"
integrity="sha384-wvfXpqpZZVQGK6TAh5PVlGOfQNHSoD2xbE+QkPxCAFlNEevoEH3Sl0sibVcOQVnN"
crossorigin="anonymous">
<link rel="stylesheet" href="/css/fluo.css">
- <link rel="canonical" href="https://fluo.apache.org//releases/";>
+ <link rel="canonical" href="https://fluo.apache.org//release/2.0.0/";>
<link rel="icon" type="image/png" href="/resources/favicon.png">
- <title>Releases | Apache Fluo</title>
+ <title>Apache Fluo 2.0.0 | Apache Fluo</title>
<script
src="https://ajax.googleapis.com/ajax/libs/jquery/3.1.1/jquery.min.js";></script>
<script
src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js";
integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa"
crossorigin="anonymous"></script>
@@ -100,79 +100,75 @@
<div class="container">
<div class="row">
<div class="col-sm-12">
- <h2 id="current">Current</h2>
-
-<div class="row">
- <a href="/release/fluo-1.2.0">
- <div class="col-sm-4 btn btn-info">
- <h3>Fluo 1.2.0</h3>
- <p>Core project containing 'fluo' command that initializes<br />
applications, starts oracle and worker processes, and<br />manages running
applications</p>
- </div>
- </a>
- <a href="/release/fluo-yarn-1.0.0">
- <div class="col-sm-4 btn btn-warning">
- <h3>Fluo YARN 1.0.0</h3>
- <p>Project containing 'fluo-yarn' command that launches<br />Fluo
applications in YARN after they have been<br />initialized using 'fluo'
command</p>
- </div>
- </a>
- <a href="/release/fluo-recipes-1.2.0">
- <div class="col-sm-4 btn btn-success">
- <h3>Fluo Recipes 1.2.0</h3>
- <p>Libraries containing common code that build on the<br />Fluo API to
offer complex transactional updates or<br />provide additional utilities<br
/></p>
- </div>
- </a>
+ <div class="post-header">
+ <h2>Apache Fluo 2.0.0</h2>
+ <p class="text-muted">18 Apr 2023</p>
+ <p><a class="twitter-share-button"
href="https://twitter.com/intent/tweet?text=Apache Fluo
2.0.0&url=https://fluo.apache.org//release/2.0.0/&via=ApacheFluo&related=ApacheFluo";
rel="nofollow" target="_blank" title="Share on Twitter">Twitter</a></p>
</div>
-<h2 id="archive">Archive</h2>
-<h3>2018</h3>
-<div class="row" style="margin-top: 15px">
- <div class="col-md-1">Mar 06</div>
- <div class="col-md-10"><a href="/release/fluo-yarn-1.0.0">Apache Fluo YARN
1.0.0</a></div>
- </div>
-<div class="row" style="margin-top: 15px">
- <div class="col-md-1">Mar 06</div>
- <div class="col-md-10"><a href="/release/fluo-recipes-1.2.0">Apache Fluo
Recipes 1.2.0</a></div>
- </div>
-<div class="row" style="margin-top: 15px">
- <div class="col-md-1">Feb 26</div>
- <div class="col-md-10"><a href="/release/fluo-1.2.0">Apache Fluo
1.2.0</a></div>
- </div>
+<div class="post-content">
+ <p>Apache Fluo is a distributed processing system that lets users make
incremental
+updates to large data sets. With Apache Fluo, users can set up workflows that
+execute cross node transactions when data changes. These workflows enable users
+to continuously join new data into large existing data sets without
+reprocessing all data. Apache Fluo is built on [Apache Accumulo].</p>
-<hr />
+<p>Below are resources for this release:</p>
-<h3>2017</h3>
+<ul>
+ <li>
+ <p>Download a release tarball and verify by these [procedures] using these
[KEYS]</p>
-<div class="row" style="margin-top: 15px">
- <div class="col-md-1">Jun 22</div>
- <div class="col-md-10"><a
href="/release/fluo-recipes-1.1.0-incubating">Apache Fluo Recipes
1.1.0-incubating</a></div>
- </div>
+ <table>
+ <tbody>
+ <tr>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-bin.tar.gz";>fluo-2.0.0-bin.tar.gz</a></td>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-bin.tar.gz.asc";>ASC</a>
<a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-bin.tar.gz.sha512";>SHA</a></td>
+ </tr>
+ <tr>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-source-release.tar.gz";>fluo-2.0.0-source-release.tar.gz</a></td>
+ <td><a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-source-release.tar.gz.asc";>ASC</a>
<a
href="https://dlcdn.apache.org/fluo/fluo/2.0.0/fluo-2.0.0-source-release.tar.gz.sha512";>SHA</a></td>
+ </tr>
+ </tbody>
+ </table>
+ </li>
+ <li>
+ <p>Read the <a
href="https://javadoc.io/doc/org.apache.fluo/fluo-api/2.0.0/index.html";>Javadocs</a>.</p>
+ </li>
+</ul>
-<div class="row" style="margin-top: 15px">
- <div class="col-md-1">Jun 12</div>
- <div class="col-md-10"><a href="/release/fluo-1.1.0-incubating">Apache
Fluo 1.1.0-incubating</a></div>
- </div>
+<p>Apache Fluo follows <a href="http://semver.org/";>semver</a> for its API .
The API consists
+of everything under the <code class="language-plaintext
highlighter-rouge">org.apache.fluo.api</code> package. Code outside of this
+package can change at any time. If your project is using Fluo code that falls
+outside of the API, then consider <a href="/getinvolved/">initiating a
discussion</a>
+about adding it to the API.</p>
-<hr />
+<h2 id="notable-changes">Notable changes</h2>
-<h3>2016</h3>
+<p>The major changes in 2.0.0 are highlighted here, for the complete list of
changes, see the <a
href="https://github.com/apache/fluo/milestone/8?closed=1";>2.0.0
+Milestone</a> on Github.</p>
-<div class="row" style="margin-top: 15px">
- <div class="col-md-1">Oct 28</div>
- <div class="col-md-10"><a
href="/release/fluo-recipes-1.0.0-incubating">Apache Fluo Recipes
1.0.0-incubating</a></div>
- </div>
+<ul>
+ <li>Many performance and bug fixes were made.</li>
+ <li>Fluo was updated to work with Accumulo 2.1.0, Java 11, and Hadoop 3</li>
+ <li>Added scan authorizations to snapshots <a
href="https://github.com/apache/fluo/pull/1120";>1120</a></li>
+ <li>Added asynchronous get methods to snapshots for reading data. <a
href="https://github.com/apache/fluo/pull/969";>969</a></li>
+ <li>Added asynchronous submit method to LoaderExecutor <a
href="https://github.com/apache/fluo/pull/1113";>1100</a></li>
+ <li>Added option to Fluo’s scan command to show notifications. <a
href="https://github.com/apache/fluo/issues/1026";>1026</a></li>
+ <li>Fluo now sets Accumulo scan hints. This can be used to optimize Fluo
server side scan execution in Accumulo. <a
href="https://github.com/apache/fluo/pull/1072";>1072</a></li>
+ <li>Summaries of Fluo’s metadata are generated in Accumulo. This could be
used to select files for compaction in Accumulo. <a
href="https://github.com/apache/fluo/pull/1071";>1071</a></li>
+</ul>
-<div class="row" style="margin-top: 15px">
- <div class="col-md-1">Oct 14</div>
- <div class="col-md-10"><a href="/release/fluo-1.0.0-incubating">Apache
Fluo 1.0.0-incubating</a></div>
- </div>
-<hr />
+</div>
-<p>Releases before joining Apache are in <a href="/pre-asf-release/">pre-ASF
archive</a>.</p>
+<div>
+ <p class="text-muted">View all releases in the <a
href="/releases/">archive</a></p>
+</div>
</div>
</div>
diff --git a/output/releases/index.html b/output/releases/index.html
index f1b6421..2f890f7 100644
--- a/output/releases/index.html
+++ b/output/releases/index.html
@@ -125,6 +125,15 @@
<h2 id="archive">Archive</h2>
+<h3>2023</h3>
+
+<div class="row" style="margin-top: 15px">
+ <div class="col-md-1">Apr 18</div>
+ <div class="col-md-10"><a href="/release/fluo-2.0.0">Apache Fluo
2.0.0</a></div>
+ </div>
+
+<hr />
+
<h3>2018</h3>
<div class="row" style="margin-top: 15px">
diff --git a/output/search_data.json b/output/search_data.json
index 55f68fc..84ca266 100644
--- a/output/search_data.json
+++ b/output/search_data.json
@@ -170,6 +170,14 @@
},
+ "release-2-0-0": {
+ "title": "Apache Fluo 2.0.0",
+ "content" : "Apache Fluo is a distributed processing system that
lets users make incrementalupdates to large data sets. With Apache Fluo, users
can set up workflows thatexecute cross node transactions when data changes.
These workflows enable usersto continuously join new data into large existing
data sets withoutreprocessing all data. Apache Fluo is built on [Apache
Accumulo].Below are resources for this release: Download a release tarball
and verify by these [procedures] [...]
+ "url": " /release/2.0.0/",
+ "categories": "release"
+ }
+ ,
+
"blog-2019-09-30-scan-executors": {
"title": "How Fluo Leveraged Scan Executors",
"content" : "Accumulo 2.0 introduced Scan Executors giving
control over processing ofscans in Accumulo tablet servers. Fluo has a good use
case for scan executors:notification scans. Fluo workers continually scan for
notifications to findtransactions to execute. All workers continually scanning
for notificationsputs load on Accumulo tablet servers which could negatively
impacttransactions. Scan executors provides a way to limit this load.Fluo
utilizes this feature by setting sca [...]
