kafka-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From guozh...@apache.org
Subject kafka-site git commit: fix broken links after PR 58
Date Sat, 01 Jul 2017 01:11:58 GMT
Repository: kafka-site
Updated Branches:
  refs/heads/asf-site 04199a2e1 -> 34f8ecea0


fix broken links after PR 58


Project: http://git-wip-us.apache.org/repos/asf/kafka-site/repo
Commit: http://git-wip-us.apache.org/repos/asf/kafka-site/commit/34f8ecea
Tree: http://git-wip-us.apache.org/repos/asf/kafka-site/tree/34f8ecea
Diff: http://git-wip-us.apache.org/repos/asf/kafka-site/diff/34f8ecea

Branch: refs/heads/asf-site
Commit: 34f8ecea0db15523ce4b81e6b6bc4c5c2fabd603
Parents: 04199a2
Author: Guozhang Wang <wangguoz@gmail.com>
Authored: Fri Jun 30 18:11:49 2017 -0700
Committer: Guozhang Wang <wangguoz@gmail.com>
Committed: Fri Jun 30 18:11:49 2017 -0700

----------------------------------------------------------------------
 0110/streams/architecture.html    |  4 ++--
 0110/streams/core-concepts.html   | 10 +++++-----
 0110/streams/developer-guide.html |  8 ++++----
 3 files changed, 11 insertions(+), 11 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/kafka-site/blob/34f8ecea/0110/streams/architecture.html
----------------------------------------------------------------------
diff --git a/0110/streams/architecture.html b/0110/streams/architecture.html
index 5070529..6269994 100644
--- a/0110/streams/architecture.html
+++ b/0110/streams/architecture.html
@@ -90,7 +90,7 @@
 
     <p>
     Kafka Streams provides so-called <b>state stores</b>, which can be used by
stream processing applications to store and query data,
-    which is an important capability when implementing stateful operations. The <a href="#streams_dsl">Kafka
Streams DSL</a>, for example, automatically creates
+    which is an important capability when implementing stateful operations. The <a href="/{{version}}/documentation/streams/developer-guide#streams_dsl">Kafka
Streams DSL</a>, for example, automatically creates
     and manages such state stores when you are calling stateful operators such as <code>join()</code>
or <code>aggregate()</code>, or when you are windowing a stream.
     </p>
 
@@ -126,7 +126,7 @@
     Note that the cost of task (re)initialization typically depends primarily on the time
for restoring the state by replaying the state stores' associated changelog topics.
     To minimize this restoration time, users can configure their applications to have <b>standby
replicas</b> of local states (i.e. fully replicated copies of the state).
     When a task migration happens, Kafka Streams then attempts to assign a task to an application
instance where such a standby replica already exists in order to minimize
-    the task (re)initialization cost. See <code>num.standby.replicas</code> in
the <a href="/{{version}}/documentation/#streamsconfigs">Kafka Streams Configs</a>
Section.
+    the task (re)initialization cost. See <code>num.standby.replicas</code> in
the <a href="/{{version}}/documentation/#streamsconfigs"><b>Kafka Streams Configs</b></a>
Section.
     </p>
 
     <div class="pagination">

http://git-wip-us.apache.org/repos/asf/kafka-site/blob/34f8ecea/0110/streams/core-concepts.html
----------------------------------------------------------------------
diff --git a/0110/streams/core-concepts.html b/0110/streams/core-concepts.html
index 28822b6..c0934ad 100644
--- a/0110/streams/core-concepts.html
+++ b/0110/streams/core-concepts.html
@@ -44,14 +44,14 @@
     <img class="centered" src="/{{version}}/images/streams-architecture-topology.jpg"
style="width:400px">
 
     <p>
-        Kafka Streams offers two ways to define the stream processing topology: the <a
href="#streams_dsl"><b>Kafka Streams DSL</b></a> provides
-        the most common data transformation operations such as <code>map</code>,
<code>filter</code>, <code>join</code> and <code>aggregations</code>
out of the box; the lower-level <a href="#streams_processor"><b>Processor API</b></a>
allows
+        Kafka Streams offers two ways to define the stream processing topology: the <a
href="/{{version}}/documentation/streams/developer-guide#streams_dsl"><b>Kafka Streams
DSL</b></a> provides
+        the most common data transformation operations such as <code>map</code>,
<code>filter</code>, <code>join</code> and <code>aggregations</code>
out of the box; the lower-level <a href="/{{version}}/documentation/streams/developer-guide#streams_processor"><b>Processor
API</b></a> allows
         developers define and connect custom processors as well as to interact with <a
href="#streams_state">state stores</a>.
     </p>
 
     <p>
         A processor topology is merely a logical abstraction for your stream processing code.
-        At runtime, the logical topology is instantiated and replicated inside the application
for parallel processing (see <a href="#streams_architecture_tasks">Stream Partitions
and Tasks</a> for details).
+        At runtime, the logical topology is instantiated and replicated inside the application
for parallel processing (see <a href="#streams_architecture_tasks"><b>Stream Partitions
and Tasks</b></a> for details).
     </p>
 
     <h3><a id="streams_time" href="#streams_time">Time</a></h3>
@@ -99,7 +99,7 @@
         Some stream processing applications don't require state, which means the processing
of a message is independent from
         the processing of all other messages.
         However, being able to maintain state opens up many possibilities for sophisticated
stream processing applications: you
-        can join input streams, or group and aggregate data records. Many such stateful operators
are provided by the <a href="#streams_dsl"><b>Kafka Streams DSL</b></a>.
+        can join input streams, or group and aggregate data records. Many such stateful operators
are provided by the <a href="/{{version}}/documentation/streams/developer-guide#streams_dsl"><b>Kafka
Streams DSL</b></a>.
     </p>
     <p>
         Kafka Streams provides so-called <b>state stores</b>, which can be used
by stream processing applications to store and query data.
@@ -131,7 +131,7 @@
         To read more details on how this is done inside Kafka Streams, readers are recommended
to read <a href="https://cwiki.apache.org/confluence/display/KAFKA/KIP-129%3A+Streams+Exactly-Once+Semantics">KIP-129</a>.
 
         In order to achieve exactly-once semantics when running Kafka Streams applications,
users can simply set the <code>processing.guarantee</code> config value to <b>exactly_once</b>
(default value is <b>at_least_once</b>).
-        More details can be found in the <a href="#streamsconfigs">Kafka Streams Configs</a>
section.
+        More details can be found in the <a href="/{{version}}/documentation#streamsconfigs">Kafka
Streams Configs</a> section.
     </p>
 
     <div class="pagination">

http://git-wip-us.apache.org/repos/asf/kafka-site/blob/34f8ecea/0110/streams/developer-guide.html
----------------------------------------------------------------------
diff --git a/0110/streams/developer-guide.html b/0110/streams/developer-guide.html
index 9ff4b3e..f2d0cf4 100644
--- a/0110/streams/developer-guide.html
+++ b/0110/streams/developer-guide.html
@@ -26,7 +26,7 @@
     </p>
 
     <p>
-    As we have mentioned above, the computational logic of a Kafka Streams application is
defined as a <a href="#streams_topology">processor topology</a>.
+    As we have mentioned above, the computational logic of a Kafka Streams application is
defined as a <a href="/{{version}}/documentation/streams/core-concepts#streams_topology">processor
topology</a>.
     Currently Kafka Streams provides two sets of APIs to define the processor topology, which
will be described in the subsequent sections.
     </p>
 
@@ -35,7 +35,7 @@
     <h4><a id="streams_processor_process" href="#streams_processor_process">Processor</a></h4>
 
     <p>
-    As mentioned in the <a href="#streams_concepts">Core Concepts</a> section,
a stream processor is a node in the processor topology that represents a single processing
step.
+    As mentioned in the <a href="/{{version}}/documentation/streams/core-concepts">Core
Concepts</a> section, a stream processor is a node in the processor topology that represents
a single processing step.
     With the <code>Processor</code> API developers can define arbitrary stream
processors that process one received record at a time, and connect these processors with
     their associated state stores to compose the processor topology that represents their
customized processing logic.
     </p>
@@ -303,7 +303,7 @@
     </p>
 
     <p>
-    Late-arriving records are always possible in real-time data streams. However, it depends
on the effective <a href="#streams_time">time semantics</a> how late records are
handled. Using processing-time, the semantics are "when the data is being processed",
+    Late-arriving records are always possible in real-time data streams. However, it depends
on the effective <a href="/{{version}}/documentation/streams/core-concepts#streams_time">time
semantics</a> how late records are handled. Using processing-time, the semantics are
"when the data is being processed",
     which means that the notion of late records is not applicable as, by definition, no record
can be late. Hence, late-arriving records only really can be considered as such (i.e. as arriving
"late") for event-time or ingestion-time semantics. In both cases,
     Kafka Streams is able to properly handle late-arriving records.
     </p>
@@ -572,7 +572,7 @@
     It is important to understand that, when starting your application as described above,
you are actually launching what Kafka Streams considers to be one instance of your application.
     More than one instance of your application may be running at a time, and in fact the
common scenario is that there are indeed multiple instances of your application running in
parallel (e.g., on another JVM or another machine).
     In such cases, Kafka Streams transparently re-assigns tasks from the existing instances
to the new instance that you just started.
-    See <a href="#streams_architecture_tasks">Stream Partitions and Tasks</a>
and <a href="#streams_architecture_threads">Threading Model</a> for details.
+    See <a href="/{{version}}/documentation/streams/architecture#streams_architecture_tasks"><b>Stream
Partitions and Tasks</b></a> and <a href="/{{version}}/documentation/streams/architecture#streams_architecture_threads"><b>Threading
Model</b></a> for details.
     </p>
 
     <div class="pagination">


Mime
View raw message