You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by al...@apache.org on 2018/04/23 20:56:03 UTC
[camel] branch master updated: Fixed typos
This is an automated email from the ASF dual-hosted git repository.
aldettinger pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/master by this push:
new 241f7bd Fixed typos
241f7bd is described below
commit 241f7bd00ba3f3a2a556ec74de15e73901051ba6
Author: aldettinger <al...@gmail.com>
AuthorDate: Mon Apr 23 22:50:41 2018 +0200
Fixed typos
---
.../src/main/docs/netty4-component.adoc | 25 +++++++++++-----------
.../camel/component/netty4/NettyComponent.java | 2 +-
.../camel/component/netty4/NettyConfiguration.java | 4 ++--
.../netty4/NettyServerBootstrapConfiguration.java | 8 +++----
.../springboot/NettyComponentConfiguration.java | 12 +++++------
5 files changed, 25 insertions(+), 26 deletions(-)
diff --git a/components/camel-netty4/src/main/docs/netty4-component.adoc b/components/camel-netty4/src/main/docs/netty4-component.adoc
index 08840e4..6bf2bdb 100644
--- a/components/camel-netty4/src/main/docs/netty4-component.adoc
+++ b/components/camel-netty4/src/main/docs/netty4-component.adoc
@@ -6,7 +6,7 @@
The *netty4* component in Camel is a socket communication component,
based on the http://netty.io/[Netty] project version 4. +
Netty is a NIO client server framework which enables quick and easy
-development of netwServerInitializerFactoryork applications such as
+development of networkServerInitializerFactory applications such as
protocol servers and clients. +
Netty greatly simplifies and streamlines network programming such as
TCP and UDP socket server.
@@ -15,7 +15,7 @@ This camel component supports both producer and consumer endpoints.
The Netty component has several options and allows fine-grained control
of a number of TCP/UDP communication parameters (buffer sizes,
-keepAlives, tcpNoDelay etc) and facilitates both In-Only and In-Out
+keepAlives, tcpNoDelay, etc) and facilitates both In-Only and In-Out
communication on a Camel route.
Maven users will need to add the following dependency to their `pom.xml`
@@ -59,7 +59,7 @@ The Netty4 component supports 5 options which are listed below.
| Name | Description | Default | Type
| *maximumPoolSize* (advanced) | The thread pool size for the EventExecutorGroup if its in use. The default value is 16. | 16 | int
| *configuration* (advanced) | To use the NettyConfiguration as configuration when creating endpoints. | | NettyConfiguration
-| *executorService* (advanced) | To use the given EventExecutorGroup | | EventExecutorGroup
+| *executorService* (advanced) | To use the given EventExecutorGroup. | | EventExecutorGroup
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL context parameters. | false | boolean
| *resolveProperty Placeholders* (advanced) | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | boolean
|===
@@ -82,7 +82,7 @@ with the following path and query parameters:
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. | | String
-| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0 For the producer the hostname is the remote host to connect to | | String
+| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to | | String
| *port* | *Required* The host port number | | int
|===
@@ -96,7 +96,7 @@ with the following path and query parameters:
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
-| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an ex [...]
+| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an e [...]
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
@@ -117,7 +117,7 @@ with the following path and query parameters:
| *serverExceptionCaughtLog Level* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory | | ServerInitializer Factory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
-| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in millis. | 10000 | int
+| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. | | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory | | ClientInitializer Factory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the [...]
@@ -140,7 +140,7 @@ with the following path and query parameters:
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
-| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads2. User can use this operation to override the default workerCount from Netty | | int
+| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads x 2. User can use this operation to override the default workerCount from Netty. | | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. | | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/deocder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
@@ -226,13 +226,12 @@ NOTE: Read below about using non shareable encoders/decoders.
==== Using non shareable encoders or decoders
-If your encoders or decoders is not shareable (eg they have the
+If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
-then the Netty component will log a WARN when +
- an endpoint is created.
+then the Netty component will log a WARN when an endpoint is created.
The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
@@ -408,7 +407,7 @@ In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
-references (to lists of ChannelUpstreamHandlers and
+references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.
@@ -536,13 +535,13 @@ from("netty4:tcp://localhost:8080").process(new Processor() {
----
[[Netty4-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
-Adding custom channel pipeline factories to gain complete control over a
+Adding custom channel pipeline factories to gain complete control over a created pipeline
=== Custom pipeline
Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
-decoders without having to specify them in the Netty Endpoint URL in a
+decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.
In order to add a custom pipeline, a custom channel pipeline factory
diff --git a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyComponent.java b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyComponent.java
index bae366c..676bfd2 100644
--- a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyComponent.java
+++ b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyComponent.java
@@ -121,7 +121,7 @@ public class NettyComponent extends UriEndpointComponent implements SSLContextPa
}
/**
- * To use the given EventExecutorGroup
+ * To use the given EventExecutorGroup.
*/
public void setExecutorService(EventExecutorGroup executorService) {
this.executorService = executorService;
diff --git a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyConfiguration.java b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyConfiguration.java
index 09b4f97..dc0753f 100644
--- a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyConfiguration.java
+++ b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyConfiguration.java
@@ -654,10 +654,10 @@ public class NettyConfiguration extends NettyServerBootstrapConfiguration implem
/**
* This option allows producers and consumers (in client mode) to reuse the same Netty {@link Channel} for the lifecycle of processing the {@link Exchange}.
* This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection.
- * When using this the channel is not returned to the connection pool until the {@link Exchange} is done; or disconnected
+ * When using this, the channel is not returned to the connection pool until the {@link Exchange} is done; or disconnected
* if the disconnect option is set to true.
* <p/>
- * The reused {@link Channel} is stored on the {@link Exchange} as an exchange property with the key {@link NettyConstants#NETTY_CHANNEL}
+ * The reused {@link Channel} is stored on the {@link Exchange} as an exchange property with the key {@link NettyConstants#NETTY_CHANNEL}
* which allows you to obtain the channel during routing and use it as well.
*/
public void setReuseChannel(boolean reuseChannel) {
diff --git a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyServerBootstrapConfiguration.java b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyServerBootstrapConfiguration.java
index 3b27409..2e9c7af 100644
--- a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyServerBootstrapConfiguration.java
+++ b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyServerBootstrapConfiguration.java
@@ -134,7 +134,7 @@ public class NettyServerBootstrapConfiguration implements Cloneable {
/**
* The hostname.
* <p/>
- * For the consumer the hostname is localhost or 0.0.0.0
+ * For the consumer the hostname is localhost or 0.0.0.0.
* For the producer the hostname is the remote host to connect to
*/
public void setHost(String host) {
@@ -201,8 +201,8 @@ public class NettyServerBootstrapConfiguration implements Cloneable {
}
/**
- * When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads*2.
- * User can use this operation to override the default workerCount from Netty
+ * When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads x 2.
+ * User can use this operation to override the default workerCount from Netty.
*/
public void setWorkerCount(int workerCount) {
this.workerCount = workerCount;
@@ -258,7 +258,7 @@ public class NettyServerBootstrapConfiguration implements Cloneable {
}
/**
- * Time to wait for a socket connection to be available. Value is in millis.
+ * Time to wait for a socket connection to be available. Value is in milliseconds.
*/
public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
diff --git a/platforms/spring-boot/components-starter/camel-netty4-starter/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java b/platforms/spring-boot/components-starter/camel-netty4-starter/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java
index ca91306..1f22388 100644
--- a/platforms/spring-boot/components-starter/camel-netty4-starter/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java
+++ b/platforms/spring-boot/components-starter/camel-netty4-starter/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java
@@ -59,7 +59,7 @@ public class NettyComponentConfiguration
*/
private NettyConfigurationNestedConfiguration configuration;
/**
- * To use the given EventExecutorGroup
+ * To use the given EventExecutorGroup.
*/
@NestedConfigurationProperty
private EventExecutorGroup executorService;
@@ -313,7 +313,7 @@ public class NettyComponentConfiguration
* the same Netty {@link Channel} for the lifecycle of processing the
* {@link Exchange} . This is useful if you need to call a server
* multiple times in a Camel route and want to use the same network
- * connection. When using this the channel is not returned to the
+ * connection. When using this, the channel is not returned to the
* connection pool until the {@link Exchange} is done; or disconnected
* if the disconnect option is set to true.
* <p/>
@@ -349,7 +349,7 @@ public class NettyComponentConfiguration
/**
* The hostname.
* <p/>
- * For the consumer the hostname is localhost or 0.0.0.0 For the
+ * For the consumer the hostname is localhost or 0.0.0.0. For the
* producer the hostname is the remote host to connect to
*/
private String host;
@@ -378,8 +378,8 @@ public class NettyComponentConfiguration
private Integer receiveBufferSizePredictor;
/**
* When netty works on nio mode, it uses default workerCount parameter
- * from Netty, which is cpu_core_threads*2. User can use this operation
- * to override the default workerCount from Netty
+ * from Netty, which is cpu_core_threads x 2. User can use this
+ * operation to override the default workerCount from Netty.
*/
private Integer workerCount;
/**
@@ -402,7 +402,7 @@ public class NettyComponentConfiguration
private Boolean reuseAddress = true;
/**
* Time to wait for a socket connection to be available. Value is in
- * millis.
+ * milliseconds.
*/
private Integer connectTimeout = 10000;
/**
--
To stop receiving notification emails like this one, please contact
aldettinger@apache.org.