kafka-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From guozh...@apache.org
Subject [kafka] branch 1.1 updated: MINOR: fix broken links in streams doc (#5025)
Date Wed, 16 May 2018 20:24:06 GMT
This is an automated email from the ASF dual-hosted git repository.

guozhang pushed a commit to branch 1.1
in repository https://gitbox.apache.org/repos/asf/kafka.git


The following commit(s) were added to refs/heads/1.1 by this push:
     new b492e8e  MINOR: fix broken links in streams doc (#5025)
b492e8e is described below

commit b492e8e85eecb39345fa410b2bbe0e3c43c3b3ae
Author: Guozhang Wang <wangguoz@gmail.com>
AuthorDate: Wed May 16 13:23:20 2018 -0700

    MINOR: fix broken links in streams doc (#5025)
    
    Reviewers: Guozhang Wang <wangguoz@gmail.com>
---
 docs/streams/developer-guide/config-streams.html      | 4 ++--
 docs/streams/developer-guide/dsl-api.html             | 8 ++++----
 docs/streams/developer-guide/interactive-queries.html | 2 +-
 docs/streams/developer-guide/running-app.html         | 6 +++---
 docs/streams/developer-guide/write-streams.html       | 2 +-
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/streams/developer-guide/config-streams.html b/docs/streams/developer-guide/config-streams.html
index 1f18a95..d1f3aa4 100644
--- a/docs/streams/developer-guide/config-streams.html
+++ b/docs/streams/developer-guide/config-streams.html
@@ -387,13 +387,13 @@
               Standby replicas are used to minimize the latency of task failover.  A task
that was previously running on a failed instance is
               preferred to restart on an instance that has standby replicas so that the local
state store restoration process from its
               changelog can be minimized.  Details about how Kafka Streams makes use of the
standby replicas to minimize the cost of
-              resuming tasks on failover can be found in the <a class="reference internal"
href="../architecture.html#streams-architecture-state"><span class="std std-ref">State</span></a>
section.</div></blockquote>
+              resuming tasks on failover can be found in the <a class="reference internal"
href="../architecture.html#streams_architecture_state"><span class="std std-ref">State</span></a>
section.</div></blockquote>
         </div>
         <div class="section" id="num-stream-threads">
           <h4><a class="toc-backref" href="#id11">num.stream.threads</a><a
class="headerlink" href="#num-stream-threads" title="Permalink to this headline"></a></h4>
           <blockquote>
             <div>This specifies the number of stream threads in an instance of the
Kafka Streams application. The stream processing code runs in these thread.
-              For more information about Kafka Streams threading model, see <a class="reference
internal" href="../architecture.html#streams-architecture-threads"><span class="std
std-ref">Threading Model</span></a>.</div></blockquote>
+              For more information about Kafka Streams threading model, see <a class="reference
internal" href="../architecture.html#streams_architecture_threads"><span class="std
std-ref">Threading Model</span></a>.</div></blockquote>
         </div>
         <div class="section" id="partition-grouper">
           <span id="streams-developer-guide-partition-grouper"></span><h4><a
class="toc-backref" href="#id12">partition.grouper</a><a class="headerlink" href="#partition-grouper"
title="Permalink to this headline"></a></h4>
diff --git a/docs/streams/developer-guide/dsl-api.html b/docs/streams/developer-guide/dsl-api.html
index 7b4d7f7..a2cfeaf 100644
--- a/docs/streams/developer-guide/dsl-api.html
+++ b/docs/streams/developer-guide/dsl-api.html
@@ -158,7 +158,7 @@
                             be populated with data from only <strong>a subset</strong>
of the partitions of the input topic.  Collectively, across
                             all application instances, all input topic partitions are read
and processed.</p>
                         <p>You must provide a name for the table (more precisely, for
the internal
-                            <a class="reference internal" href="../architecture.html#streams-architecture-state"><span
class="std std-ref">state store</span></a> that backs the table).  This is
required for
+                            <a class="reference internal" href="../architecture.html#streams_architecture_state"><span
class="std std-ref">state store</span></a> that backs the table).  This is
required for
                             supporting <a class="reference internal" href="interactive-queries.html#streams-developer-guide-interactive-queries"><span
class="std std-ref">interactive queries</span></a> against the table. When
a
                             name is not provided the table will not queryable and an internal
name will be provided for the state store.</p>
                         <p>If you do not specify SerDes explicitly, the default SerDes
from the
@@ -182,7 +182,7 @@
                         <p>In the case of a GlobalKTable, the local GlobalKTable instance
of every application instance will
                             be populated with data from <strong>all</strong>
the partitions of the input topic.</p>
                         <p>You must provide a name for the table (more precisely, for
the internal
-                            <a class="reference internal" href="../architecture.html#streams-architecture-state"><span
class="std std-ref">state store</span></a> that backs the table).  This is
required for
+                            <a class="reference internal" href="../architecture.html#streams_architecture_state"><span
class="std std-ref">state store</span></a> that backs the table).  This is
required for
                             supporting <a class="reference internal" href="interactive-queries.html#streams-developer-guide-interactive-queries"><span
class="std std-ref">interactive queries</span></a> against the table. When
a
                             name is not provided the table will not queryable and an internal
name will be provided for the state store.</p>
                         <div class="highlight-java"><div class="highlight"><pre><span></span><span
class="kn">import</span> <span class="nn">org.apache.kafka.common.serialization.Serdes</span><span
class="o">;</span>
@@ -683,12 +683,12 @@
             </div>
             <div class="section" id="stateful-transformations">
                 <span id="streams-developer-guide-dsl-transformations-stateful"></span><h3><a
class="toc-backref" href="#id11">Stateful transformations</a><a class="headerlink"
href="#stateful-transformations" title="Permalink to this headline"></a></h3>
-                <p id="streams-developer-guide-dsl-transformations-stateful-overview">Stateful
transformations depend on state for processing inputs and producing outputs and require a
<a class="reference internal" href="../architecture.html#streams-architecture-state"><span
class="std std-ref">state store</span></a> associated with the stream processor.
For example, in aggregating operations, a windowing state store is used to collect the latest
aggregation results per
+                <p id="streams-developer-guide-dsl-transformations-stateful-overview">Stateful
transformations depend on state for processing inputs and producing outputs and require a
<a class="reference internal" href="../architecture.html#streams_architecture_state"><span
class="std std-ref">state store</span></a> associated with the stream processor.
For example, in aggregating operations, a windowing state store is used to collect the latest
aggregation results per
                     window. In join operations, a windowing state store is used to collect
all of the records received so far within the
                     defined window boundary.</p>
                 <p>Note, that state stores are fault-tolerant.
                     In case of failure, Kafka Streams guarantees to fully restore all state
stores prior to resuming the processing.
-                    See <a class="reference internal" href="../architecture.html#streams-architecture-fault-tolerance"><span
class="std std-ref">Fault Tolerance</span></a> for further information.</p>
+                    See <a class="reference internal" href="../architecture.html#streams_architecture_recovery"><span
class="std std-ref">Fault Tolerance</span></a> for further information.</p>
                 <p>Available stateful transformations in the DSL include:</p>
                 <ul class="simple">
                     <li><a class="reference internal" href="#streams-developer-guide-dsl-aggregating"><span
class="std std-ref">Aggregating</span></a></li>
diff --git a/docs/streams/developer-guide/interactive-queries.html b/docs/streams/developer-guide/interactive-queries.html
index 4675d8a..9b64ddb 100644
--- a/docs/streams/developer-guide/interactive-queries.html
+++ b/docs/streams/developer-guide/interactive-queries.html
@@ -52,7 +52,7 @@
                 <li><a class="reference internal" href="#demo-applications" id="id11">Demo
applications</a></li>
             </ul>
         </div>
-        <p>The full state of your application is typically <a class="reference internal"
href="../architecture.html#streams-architecture-state"><span class="std std-ref">split
across many distributed instances of your application</span></a>, and across many
state stores that are managed locally by these application instances.</p>
+        <p>The full state of your application is typically <a class="reference internal"
href="../architecture.html#streams_architecture_state"><span class="std std-ref">split
across many distributed instances of your application</span></a>, and across many
state stores that are managed locally by these application instances.</p>
         <div class="figure align-center">
             <img class="centered" src="/{{version}}/images/streams-interactive-queries-03.png">
         </div>
diff --git a/docs/streams/developer-guide/running-app.html b/docs/streams/developer-guide/running-app.html
index bd1a77e..f83210d 100644
--- a/docs/streams/developer-guide/running-app.html
+++ b/docs/streams/developer-guide/running-app.html
@@ -77,7 +77,7 @@ $ java -cp path-to-app-fatjar.jar com.example.MyStreamsApp
                   <a class="reference internal" href="../code-examples.html#streams-code-examples"><span
class="std std-ref">Streams code examples</span></a>.</p>
               <p>When you start your application you are launching a Kafka Streams
instance of your application. You can run multiple
                   instances of your application. A common scenario is that there are multiple
instances of your application running in
-                  parallel. For more information, see <a class="reference internal" href="../architecture.html#streams-architecture-parallelism-model"><span
class="std std-ref">Parallelism Model</span></a>.</p>
+                  parallel. For more information, see <a class="reference internal" href="../architecture.html#streams_architecture_tasks"><span
class="std std-ref">Parallelism Model</span></a>.</p>
               <p>When the application instance starts running, the defined processor
topology will be initialized as one or more stream tasks.
                   If the processor topology defines any state stores, these are also constructed
during the initialization period. For
                   more information, see the  <a class="reference internal" href="#streams-developer-guide-execution-scaling-state-restoration"><span
class="std std-ref">State restoration during workload rebalance</span></a>
section).</p>
@@ -87,7 +87,7 @@ $ java -cp path-to-app-fatjar.jar com.example.MyStreamsApp
               <p>Kafka Streams makes your stream processing applications elastic and
scalable.  You can add and remove processing capacity
                   dynamically during application runtime without any downtime or data loss.
 This makes your applications
                   resilient in the face of failures and for allows you to perform maintenance
as needed (e.g. rolling upgrades).</p>
-              <p>For more information about this elasticity, see the <a class="reference
internal" href="../architecture.html#streams-architecture-parallelism-model"><span class="std
std-ref">Parallelism Model</span></a> section. Kafka Streams
+              <p>For more information about this elasticity, see the <a class="reference
internal" href="../architecture.html#streams_architecture_tasks"><span class="std std-ref">Parallelism
Model</span></a> section. Kafka Streams
                   leverages the Kafka group management functionality, which is built right
into the <a class="reference external" href="https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol">Kafka
wire protocol</a>. It is the foundation that enables the
                   elasticity of Kafka Streams applications: members of a group coordinate
and collaborate jointly on the consumption and
                   processing of data in Kafka.  Additionally, Kafka Streams provides stateful
processing and allows for fault-tolerant
@@ -128,7 +128,7 @@ $ java -cp path-to-app-fatjar.jar com.example.MyStreamsApp
                       <li>If no local state store exists, the changelog is replayed
from the earliest to the current offset. This reconstructs the local state store to the most
recent snapshot.</li>
                       <li>If a local state store exists, the changelog is replayed
from the previously checkpointed offset. The changes are applied and the state is restored
to the most recent snapshot. This method takes less time because it is applying a smaller
portion of the changelog.</li>
                   </ul>
-                  <p>For more information, see <a class="reference internal" href="config-streams.html#streams-developer-guide-standby-replicas"><span
class="std std-ref">Standby Replicas</span></a>.</p>
+                  <p>For more information, see <a class="reference internal" href="config-streams.html#num-standby-replicas"><span
class="std std-ref">Standby Replicas</span></a>.</p>
               </div>
               <div class="section" id="determining-how-many-application-instances-to-run">
                   <h3><a class="toc-backref" href="#id8">Determining how many
application instances to run</a><a class="headerlink" href="#determining-how-many-application-instances-to-run"
title="Permalink to this headline"></a></h3>
diff --git a/docs/streams/developer-guide/write-streams.html b/docs/streams/developer-guide/write-streams.html
index 1e4213d..6e49945 100644
--- a/docs/streams/developer-guide/write-streams.html
+++ b/docs/streams/developer-guide/write-streams.html
@@ -144,7 +144,7 @@
       </div>
       <p>If there are other instances of this stream processing application running
elsewhere (e.g., on another machine), Kafka
         Streams transparently re-assigns tasks from the existing instances to the new instance
that you just started.
-        For more information, see <a class="reference internal" href="../architecture.html#streams-architecture-tasks"><span
class="std std-ref">Stream Partitions and Tasks</span></a> and <a class="reference
internal" href="../architecture.html#streams-architecture-threads"><span class="std
std-ref">Threading Model</span></a>.</p>
+        For more information, see <a class="reference internal" href="../architecture.html#streams_architecture_tasks"><span
class="std std-ref">Stream Partitions and Tasks</span></a> and <a class="reference
internal" href="../architecture.html#streams-architecture-threads"><span class="std
std-ref">Threading Model</span></a>.</p>
       <p>To catch any unexpected exceptions, you can set an <code class="docutils
literal"><span class="pre">java.lang.Thread.UncaughtExceptionHandler</span></code>
before you start the
         application.  This handler is called whenever a stream thread is terminated by an
unexpected exception:</p>
       <div class="highlight-java"><div class="highlight"><pre><span></span><span
class="c1">// Java 8+, using lambda expressions</span>

-- 
To stop receiving notification emails like this one, please contact
guozhang@apache.org.

Mime
View raw message