camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject [06/11] camel git commit: CAMEL-10197: Added plain get/set to components for spring-boot configuration
Date Tue, 02 Aug 2016 06:43:34 GMT
http://git-wip-us.apache.org/repos/asf/camel/blob/bdab2fc6/components/camel-netty4/src/main/docs/netty4.adoc
----------------------------------------------------------------------
diff --git a/components/camel-netty4/src/main/docs/netty4.adoc b/components/camel-netty4/src/main/docs/netty4.adoc
index b6bb378..d039a6e 100644
--- a/components/camel-netty4/src/main/docs/netty4.adoc
+++ b/components/camel-netty4/src/main/docs/netty4.adoc
@@ -56,8 +56,9 @@ Options
 
 
 
+
 // component options: START
-The Netty4 component supports 3 options which are listed below.
+The Netty4 component supports 69 options which are listed below.
 
 
 
@@ -66,8 +67,74 @@ The Netty4 component supports 3 options which are listed below.
 |=======================================================================
 | Name | Java Type | Description
 | maximumPoolSize | int | The thread pool size for the EventExecutorGroup if its in use. The default value is 16.
-| configuration | NettyConfiguration | To use the NettyConfiguration as configuration when creating endpoints.
+| configuration | NettyConfiguration | To use the NettyConfiguration as configuration when creating endpoints. Properties of the shared configuration can also be set individually.
 | executorService | EventExecutorGroup | To use the given EventExecutorGroup
+| protocol | String | The protocol to use which can be tcp or udp.
+| host | String | 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
+| port | int | The host port number
+| broadcast | boolean | Setting to choose Multicast over UDP
+| sendBufferSize | int | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes.
+| receiveBufferSize | int | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes.
+| receiveBufferSizePredictor | int | Configures the buffer size predictor. See details at Jetty documentation and this mail thread.
+| workerCount | int | 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
+| bossCount | int | When netty works on nio mode it uses default bossCount parameter from Netty which is 1. User can use this operation to override the default bossCount from Netty
+| keepAlive | boolean | Setting to ensure socket is not closed due to inactivity
+| tcpNoDelay | boolean | Setting to improve TCP protocol performance
+| reuseAddress | boolean | Setting to facilitate socket multiplexing
+| connectTimeout | int | Time to wait for a socket connection to be available. Value is in millis.
+| backlog | int | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200 500 or 1000 tells the TCP stack how long the accept queue can be If this option is not configured then the backlog depends on OS setting.
+| ssl | boolean | Setting to specify whether SSL encryption is applied to this endpoint
+| sslClientCertHeaders | boolean | When enabled and in SSL mode then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name issuer name serial number and the valid date range.
+| sslHandler | SslHandler | Reference to a class that could be used to return an SSL Handler
+| sslContextParameters | SSLContextParameters | To configure security using SSLContextParameters
+| needClientAuth | boolean | Configures whether the server needs client authentication when using SSL.
+| keyStoreResource | String | Client side certificate keystore to be used for encryption. Is loaded by default from classpath but you can prefix with classpath: file: or http: to load the resource from different systems.
+| trustStoreResource | String | Server side certificate keystore to be used for encryption. Is loaded by default from classpath but you can prefix with classpath: file: or http: to load the resource from different systems.
+| keyStoreFormat | String | Keystore format to be used for payload encryption. Defaults to JKS if not set
+| securityProvider | String | Security provider to be used for payload encryption. Defaults to SunX509 if not set.
+| passphrase | String | Password setting to use in order to encrypt/decrypt payloads sent using SSH
+| serverInitializerFactory | ServerInitializerFactory | To use a custom ServerInitializerFactory
+| nettyServerBootstrapFactory | NettyServerBootstrapFactory | To use a custom NettyServerBootstrapFactory
+| requestTimeout | long | 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.
+| sync | boolean | Setting to set endpoint as one-way or request-response
+| options | Map | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used.
+| textline | boolean | Only used for TCP. If no codec is specified you can use this flag to indicate a text line based codec; if not specified or the value is false then Object Serialization is assumed over TCP.
+| nativeTransport | boolean | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: http://netty.io/wiki/native-transports.html
+| decoderMaxLineLength | int | The max line length to use for the textline codec.
+| bossGroup | EventLoopGroup | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint
+| delimiter | TextLineDelimiter | The delimiter to use for the textline codec. Possible values are LINE and NULL.
+| autoAppendDelimiter | boolean | Whether or not to auto append missing end delimiter when sending using the textline codec.
+| workerGroup | EventLoopGroup | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers. By default each consumer has their own boss pool with 1 core thread.
+| channelGroup | ChannelGroup | To use a explicit ChannelGroup.
+| encoding | String | The encoding (a charset name) to use for the textline codec. If not provided Camel will use the JVM default Charset.
+| networkInterface | String | When using UDP then this option can be used to specify a network interface by its name such as eth0 to join a multicast group.
+| decoders | List | A list of decoders to be used. You can use a String which have values separated by comma and have the values be looked up in the Registry. Just remember to prefix the value with so Camel knows it should lookup.
+| enabledProtocols | String | Which protocols to enable when using SSL
+| encoders | List | A list of encoders to be used. You can use a String which have values separated by comma and have the values be looked up in the Registry. Just remember to prefix the value with so Camel knows it should lookup.
+| reconnect | boolean | Used only in clientMode in consumer the consumer will attempt to reconnect on disconnection if this is enabled
+| encoder | ChannelHandler | A custom ChannelHandler class that can be used to perform special marshalling of outbound payloads.
+| reconnectInterval | int | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection
+| decoder | ChannelHandler | A custom ChannelHandler class that can be used to perform special marshalling of inbound payloads.
+| disconnect | boolean | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer.
+| lazyChannelCreation | boolean | Channels can be lazily created to avoid exceptions if the remote server is not up and running when the Camel producer is started.
+| transferExchange | boolean | 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.
+| disconnectOnNoReply | boolean | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back.
+| noReplyLogLevel | LoggingLevel | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back.
+| serverExceptionCaughtLogLevel | LoggingLevel | If the server (NettyConsumer) catches an exception then its logged using this logging level.
+| serverClosedChannelExceptionCaughtLogLevel | LoggingLevel | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server.
+| allowDefaultCodec | boolean | 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.
+| clientInitializerFactory | ClientInitializerFactory | To use a custom ClientInitializerFactory
+| usingExecutorService | boolean | Whether to use ordered thread pool to ensure events are processed orderly on the same channel.
+| producerPoolMaxActive | int | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients or idle awaiting checkout) at a given time. Use a negative value for no limit.
+| producerPoolMinIdle | int | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects.
+| producerPoolMaxIdle | int | Sets the cap on the number of idle instances in the pool.
+| producerPoolMinEvictableIdle | long | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor.
+| producerPoolEnabled | boolean | Whether producer pool is enabled or not. Important: Do not turn this off as the pooling is needed for handling concurrency and reliable request/reply.
+| udpConnectionlessSending | boolean | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port.
+| clientMode | boolean | If the clientMode is true netty consumer will connect the address as a TCP client.
+| useByteBuf | boolean | If the useByteBuf is true netty producer will turn the message body into ByteBuf before sending it out.
+| udpByteArrayCodec | boolean | For UDP only. If enabled the using byte array codec instead of Java serialization protocol.
+| reuseChannel | boolean | This option allows producers to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useable 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 exchange property with the key link NettyConstantsNETTY_CHANNEL which allows you to obtain the channel during routing and use it as well.
 |=======================================================================
 {% endraw %}
 // component options: END
@@ -80,6 +147,7 @@ The Netty4 component supports 3 options which are listed below.
 
 
 
+
 // endpoint options: START
 The Netty4 component supports 73 endpoint options which are listed below:
 

http://git-wip-us.apache.org/repos/asf/camel/blob/bdab2fc6/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/NettyComponent.java
----------------------------------------------------------------------
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 048d054..601f952 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
@@ -18,17 +18,24 @@ package org.apache.camel.component.netty4;
 
 import java.net.URI;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ThreadFactory;
 
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.group.ChannelGroup;
+import io.netty.handler.ssl.SslHandler;
 import io.netty.util.concurrent.DefaultEventExecutorGroup;
 import io.netty.util.concurrent.EventExecutorGroup;
 
 import org.apache.camel.CamelContext;
 import org.apache.camel.Endpoint;
+import org.apache.camel.LoggingLevel;
 import org.apache.camel.impl.UriEndpointComponent;
 import org.apache.camel.util.IntrospectionSupport;
 import org.apache.camel.util.concurrent.CamelThreadFactory;
+import org.apache.camel.util.jsse.SSLContextParameters;
 
 public class NettyComponent extends UriEndpointComponent {
     private NettyConfiguration configuration;
@@ -102,7 +109,7 @@ public class NettyComponent extends UriEndpointComponent {
     }
 
     /**
-     * To use the NettyConfiguration as configuration when creating endpoints.
+     * To use the NettyConfiguration as configuration when creating endpoints. Properties of the shared configuration can also be set individually.
      */
     public void setConfiguration(NettyConfiguration configuration) {
         this.configuration = configuration;
@@ -153,4 +160,846 @@ public class NettyComponent extends UriEndpointComponent {
         super.doStop();
     }
 
+    private NettyConfiguration getConfigurationOrCreate() {
+        if (this.getConfiguration() == null) {
+            this.setConfiguration(new NettyConfiguration());
+        }
+        return this.getConfiguration();
+    }
+
+    public String getAddress() {
+        return getConfigurationOrCreate().getAddress();
+    }
+
+    public boolean isTcp() {
+        return getConfigurationOrCreate().isTcp();
+    }
+
+    public String getProtocol() {
+        return getConfigurationOrCreate().getProtocol();
+    }
+
+    /**
+     * The protocol to use which can be tcp or udp.
+     * @param protocol
+     */
+    public void setProtocol(String protocol) {
+        getConfigurationOrCreate().setProtocol(protocol);
+    }
+
+    public String getHost() {
+        return getConfigurationOrCreate().getHost();
+    }
+
+    /**
+     * The hostname.
+     * <p/>
+     * For the consumer the hostname is localhost or 0.0.0.0
+     * For the producer the hostname is the remote host to connect to
+     * @param host
+     */
+    public void setHost(String host) {
+        getConfigurationOrCreate().setHost(host);
+    }
+
+    public int getPort() {
+        return getConfigurationOrCreate().getPort();
+    }
+
+    /**
+     * The host port number
+     * @param port
+     */
+    public void setPort(int port) {
+        getConfigurationOrCreate().setPort(port);
+    }
+
+    public boolean isBroadcast() {
+        return getConfigurationOrCreate().isBroadcast();
+    }
+
+    /**
+     * Setting to choose Multicast over UDP
+     * @param broadcast
+     */
+    public void setBroadcast(boolean broadcast) {
+        getConfigurationOrCreate().setBroadcast(broadcast);
+    }
+
+    public int getSendBufferSize() {
+        return getConfigurationOrCreate().getSendBufferSize();
+    }
+
+    /**
+     * The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes.
+     * @param sendBufferSize
+     */
+    public void setSendBufferSize(int sendBufferSize) {
+        getConfigurationOrCreate().setSendBufferSize(sendBufferSize);
+    }
+
+    public int getReceiveBufferSize() {
+        return getConfigurationOrCreate().getReceiveBufferSize();
+    }
+
+    /**
+     * The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes.
+     * @param receiveBufferSize
+     */
+    public void setReceiveBufferSize(int receiveBufferSize) {
+        getConfigurationOrCreate().setReceiveBufferSize(receiveBufferSize);
+    }
+
+    public int getReceiveBufferSizePredictor() {
+        return getConfigurationOrCreate().getReceiveBufferSizePredictor();
+    }
+
+    /**
+     * Configures the buffer size predictor. See details at Jetty documentation and this mail thread.
+     * @param receiveBufferSizePredictor
+     */
+    public void setReceiveBufferSizePredictor(int receiveBufferSizePredictor) {
+        getConfigurationOrCreate().setReceiveBufferSizePredictor(receiveBufferSizePredictor);
+    }
+
+    public int getWorkerCount() {
+        return getConfigurationOrCreate().getWorkerCount();
+    }
+
+    /**
+     * 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
+     * @param workerCount
+     */
+    public void setWorkerCount(int workerCount) {
+        getConfigurationOrCreate().setWorkerCount(workerCount);
+    }
+
+    public int getBossCount() {
+        return getConfigurationOrCreate().getBossCount();
+    }
+
+    /**
+     * When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1.
+     * User can use this operation to override the default bossCount from Netty
+     * @param bossCount
+     */
+    public void setBossCount(int bossCount) {
+        getConfigurationOrCreate().setBossCount(bossCount);
+    }
+
+    public boolean isKeepAlive() {
+        return getConfigurationOrCreate().isKeepAlive();
+    }
+
+    /**
+     * Setting to ensure socket is not closed due to inactivity
+     * @param keepAlive
+     */
+    public void setKeepAlive(boolean keepAlive) {
+        getConfigurationOrCreate().setKeepAlive(keepAlive);
+    }
+
+    public boolean isTcpNoDelay() {
+        return getConfigurationOrCreate().isTcpNoDelay();
+    }
+
+    /**
+     * Setting to improve TCP protocol performance
+     * @param tcpNoDelay
+     */
+    public void setTcpNoDelay(boolean tcpNoDelay) {
+        getConfigurationOrCreate().setTcpNoDelay(tcpNoDelay);
+    }
+
+    public boolean isReuseAddress() {
+        return getConfigurationOrCreate().isReuseAddress();
+    }
+
+    /**
+     * Setting to facilitate socket multiplexing
+     * @param reuseAddress
+     */
+    public void setReuseAddress(boolean reuseAddress) {
+        getConfigurationOrCreate().setReuseAddress(reuseAddress);
+    }
+
+    public int getConnectTimeout() {
+        return getConfigurationOrCreate().getConnectTimeout();
+    }
+
+    /**
+     * Time to wait for a socket connection to be available. Value is in millis.
+     * @param connectTimeout
+     */
+    public void setConnectTimeout(int connectTimeout) {
+        getConfigurationOrCreate().setConnectTimeout(connectTimeout);
+    }
+
+    public int getBacklog() {
+        return getConfigurationOrCreate().getBacklog();
+    }
+
+    /**
+     * Allows to configure a backlog for netty consumer (server).
+     * Note the backlog is just a best effort depending on the OS.
+     * Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the "accept" queue can be
+     * If this option is not configured, then the backlog depends on OS setting.
+     * @param backlog
+     */
+    public void setBacklog(int backlog) {
+        getConfigurationOrCreate().setBacklog(backlog);
+    }
+
+    public boolean isSsl() {
+        return getConfigurationOrCreate().isSsl();
+    }
+
+    /**
+     * Setting to specify whether SSL encryption is applied to this endpoint
+     * @param ssl
+     */
+    public void setSsl(boolean ssl) {
+        getConfigurationOrCreate().setSsl(ssl);
+    }
+
+    public boolean isSslClientCertHeaders() {
+        return getConfigurationOrCreate().isSslClientCertHeaders();
+    }
+
+    /**
+     * When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having
+     * information about the client certificate such as subject name, issuer name, serial number, and the valid date range.
+     * @param sslClientCertHeaders
+     */
+    public void setSslClientCertHeaders(boolean sslClientCertHeaders) {
+        getConfigurationOrCreate().setSslClientCertHeaders(sslClientCertHeaders);
+    }
+
+    public SslHandler getSslHandler() {
+        return getConfigurationOrCreate().getSslHandler();
+    }
+
+    /**
+     * Reference to a class that could be used to return an SSL Handler
+     * @param sslHandler
+     */
+    public void setSslHandler(SslHandler sslHandler) {
+        getConfigurationOrCreate().setSslHandler(sslHandler);
+    }
+
+    public SSLContextParameters getSslContextParameters() {
+        return getConfigurationOrCreate().getSslContextParameters();
+    }
+
+    /**
+     * To configure security using SSLContextParameters
+     * @param sslContextParameters
+     */
+    public void setSslContextParameters(SSLContextParameters sslContextParameters) {
+        getConfigurationOrCreate().setSslContextParameters(sslContextParameters);
+    }
+
+    public boolean isNeedClientAuth() {
+        return getConfigurationOrCreate().isNeedClientAuth();
+    }
+
+    /**
+     * Configures whether the server needs client authentication when using SSL.
+     * @param needClientAuth
+     */
+    public void setNeedClientAuth(boolean needClientAuth) {
+        getConfigurationOrCreate().setNeedClientAuth(needClientAuth);
+    }
+
+    public String getKeyStoreResource() {
+        return getConfigurationOrCreate().getKeyStoreResource();
+    }
+
+    /**
+     * Client side certificate keystore to be used for encryption. Is loaded by default from classpath,
+     * but you can prefix with "classpath:", "file:", or "http:" to load the resource from different systems.
+     * @param keyStoreResource
+     */
+    public void setKeyStoreResource(String keyStoreResource) {
+        getConfigurationOrCreate().setKeyStoreResource(keyStoreResource);
+    }
+
+    public String getTrustStoreResource() {
+        return getConfigurationOrCreate().getTrustStoreResource();
+    }
+
+    /**
+     * Server side certificate keystore to be used for encryption.
+     * Is loaded by default from classpath, but you can prefix with "classpath:", "file:", or "http:" to load the resource from different systems.
+     * @param trustStoreResource
+     */
+    public void setTrustStoreResource(String trustStoreResource) {
+        getConfigurationOrCreate().setTrustStoreResource(trustStoreResource);
+    }
+
+    public String getKeyStoreFormat() {
+        return getConfigurationOrCreate().getKeyStoreFormat();
+    }
+
+    /**
+     * Keystore format to be used for payload encryption. Defaults to "JKS" if not set
+     * @param keyStoreFormat
+     */
+    public void setKeyStoreFormat(String keyStoreFormat) {
+        getConfigurationOrCreate().setKeyStoreFormat(keyStoreFormat);
+    }
+
+    public String getSecurityProvider() {
+        return getConfigurationOrCreate().getSecurityProvider();
+    }
+
+    /**
+     * Security provider to be used for payload encryption. Defaults to "SunX509" if not set.
+     * @param securityProvider
+     */
+    public void setSecurityProvider(String securityProvider) {
+        getConfigurationOrCreate().setSecurityProvider(securityProvider);
+    }
+
+    public String getPassphrase() {
+        return getConfigurationOrCreate().getPassphrase();
+    }
+
+    /**
+     * Password setting to use in order to encrypt/decrypt payloads sent using SSH
+     * @param passphrase
+     */
+    public void setPassphrase(String passphrase) {
+        getConfigurationOrCreate().setPassphrase(passphrase);
+    }
+
+    public ServerInitializerFactory getServerInitializerFactory() {
+        return getConfigurationOrCreate().getServerInitializerFactory();
+    }
+
+    public String getCharsetName() {
+        return getConfigurationOrCreate().getCharsetName();
+    }
+
+    /**
+     * To use a custom ServerInitializerFactory
+     * @param serverInitializerFactory
+     */
+    public void setServerInitializerFactory(ServerInitializerFactory serverInitializerFactory) {
+        getConfigurationOrCreate().setServerInitializerFactory(serverInitializerFactory);
+    }
+
+    public NettyServerBootstrapFactory getNettyServerBootstrapFactory() {
+        return getConfigurationOrCreate().getNettyServerBootstrapFactory();
+    }
+
+    public long getRequestTimeout() {
+        return getConfigurationOrCreate().getRequestTimeout();
+    }
+
+    /**
+     * To use a custom NettyServerBootstrapFactory
+     * @param nettyServerBootstrapFactory
+     */
+    public void setNettyServerBootstrapFactory(NettyServerBootstrapFactory nettyServerBootstrapFactory) {
+        getConfigurationOrCreate().setNettyServerBootstrapFactory(nettyServerBootstrapFactory);
+    }
+
+    public Map<String, Object> getOptions() {
+        return getConfigurationOrCreate().getOptions();
+    }
+
+    /**
+     * 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.
+     * @param requestTimeout
+     */
+    public void setRequestTimeout(long requestTimeout) {
+        getConfigurationOrCreate().setRequestTimeout(requestTimeout);
+    }
+
+    public boolean isSync() {
+        return getConfigurationOrCreate().isSync();
+    }
+
+    /**
+     * Setting to set endpoint as one-way or request-response
+     * @param sync
+     */
+    public void setSync(boolean sync) {
+        getConfigurationOrCreate().setSync(sync);
+    }
+
+    /**
+     * Allows to configure additional netty options using "option." as prefix.
+     * For example "option.child.keepAlive=false" to set the netty option "child.keepAlive=false". See the Netty documentation for possible options that can be used.
+     * @param options
+     */
+    public void setOptions(Map<String, Object> options) {
+        getConfigurationOrCreate().setOptions(options);
+    }
+
+    public boolean isTextline() {
+        return getConfigurationOrCreate().isTextline();
+    }
+
+    public boolean isNativeTransport() {
+        return getConfigurationOrCreate().isNativeTransport();
+    }
+
+    /**
+     * Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec;
+     * if not specified or the value is false, then Object Serialization is assumed over TCP.
+     * @param textline
+     */
+    public void setTextline(boolean textline) {
+        getConfigurationOrCreate().setTextline(textline);
+    }
+
+    public int getDecoderMaxLineLength() {
+        return getConfigurationOrCreate().getDecoderMaxLineLength();
+    }
+
+    /**
+     * Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms.
+     * You need to add the netty JAR for the host operating system you are using. See more details at: http://netty.io/wiki/native-transports.html
+     * @param nativeTransport
+     */
+    public void setNativeTransport(boolean nativeTransport) {
+        getConfigurationOrCreate().setNativeTransport(nativeTransport);
+    }
+
+    /**
+     * The max line length to use for the textline codec.
+     * @param decoderMaxLineLength
+     */
+    public void setDecoderMaxLineLength(int decoderMaxLineLength) {
+        getConfigurationOrCreate().setDecoderMaxLineLength(decoderMaxLineLength);
+    }
+
+    public EventLoopGroup getBossGroup() {
+        return getConfigurationOrCreate().getBossGroup();
+    }
+
+    public TextLineDelimiter getDelimiter() {
+        return getConfigurationOrCreate().getDelimiter();
+    }
+
+    /**
+     * Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint
+     * @param bossGroup
+     */
+    public void setBossGroup(EventLoopGroup bossGroup) {
+        getConfigurationOrCreate().setBossGroup(bossGroup);
+    }
+
+    /**
+     * The delimiter to use for the textline codec. Possible values are LINE and NULL.
+     * @param delimiter
+     */
+    public void setDelimiter(TextLineDelimiter delimiter) {
+        getConfigurationOrCreate().setDelimiter(delimiter);
+    }
+
+    public EventLoopGroup getWorkerGroup() {
+        return getConfigurationOrCreate().getWorkerGroup();
+    }
+
+    public boolean isAutoAppendDelimiter() {
+        return getConfigurationOrCreate().isAutoAppendDelimiter();
+    }
+
+    /**
+     * Whether or not to auto append missing end delimiter when sending using the textline codec.
+     * @param autoAppendDelimiter
+     */
+    public void setAutoAppendDelimiter(boolean autoAppendDelimiter) {
+        getConfigurationOrCreate().setAutoAppendDelimiter(autoAppendDelimiter);
+    }
+
+    /**
+     * To use a explicit EventLoopGroup as the boss thread pool.
+     * For example to share a thread pool with multiple consumers. By default each consumer has their own boss pool with 1 core thread.
+     * @param workerGroup
+     */
+    public void setWorkerGroup(EventLoopGroup workerGroup) {
+        getConfigurationOrCreate().setWorkerGroup(workerGroup);
+    }
+
+    public String getEncoding() {
+        return getConfigurationOrCreate().getEncoding();
+    }
+
+    public ChannelGroup getChannelGroup() {
+        return getConfigurationOrCreate().getChannelGroup();
+    }
+
+    /**
+     * To use a explicit ChannelGroup.
+     * @param channelGroup
+     */
+    public void setChannelGroup(ChannelGroup channelGroup) {
+        getConfigurationOrCreate().setChannelGroup(channelGroup);
+    }
+
+    /**
+     * The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset.
+     * @param encoding
+     */
+    public void setEncoding(String encoding) {
+        getConfigurationOrCreate().setEncoding(encoding);
+    }
+
+    public String getNetworkInterface() {
+        return getConfigurationOrCreate().getNetworkInterface();
+    }
+
+    public List<ChannelHandler> getDecoders() {
+        return getConfigurationOrCreate().getDecoders();
+    }
+
+    /**
+     * When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group.
+     * @param networkInterface
+     */
+    public void setNetworkInterface(String networkInterface) {
+        getConfigurationOrCreate().setNetworkInterface(networkInterface);
+    }
+
+    /**
+     * A list of decoders to be used.
+     * You can use a String which have values separated by comma, and have the values be looked up in the Registry.
+     * Just remember to prefix the value with # so Camel knows it should lookup.
+     * @param decoders
+     */
+    public void setDecoders(List<ChannelHandler> decoders) {
+        getConfigurationOrCreate().setDecoders(decoders);
+    }
+
+    public String getEnabledProtocols() {
+        return getConfigurationOrCreate().getEnabledProtocols();
+    }
+
+    public List<ChannelHandler> getEncoders() {
+        return getConfigurationOrCreate().getEncoders();
+    }
+
+    /**
+     * Which protocols to enable when using SSL
+     * @param enabledProtocols
+     */
+    public void setEnabledProtocols(String enabledProtocols) {
+        getConfigurationOrCreate().setEnabledProtocols(enabledProtocols);
+    }
+
+    /**
+     * Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled
+     */
+    public boolean isReconnect() {
+        return getConfigurationOrCreate().isReconnect();
+    }
+
+    /**
+     * A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry.
+     * Just remember to prefix the value with # so Camel knows it should lookup.
+     * @param encoders
+     */
+    public void setEncoders(List<ChannelHandler> encoders) {
+        getConfigurationOrCreate().setEncoders(encoders);
+    }
+
+    public void setReconnect(boolean reconnect) {
+        getConfigurationOrCreate().setReconnect(reconnect);
+    }
+
+    public ChannelHandler getEncoder() {
+        return getConfigurationOrCreate().getEncoder();
+    }
+
+    /**
+     * Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection
+     */
+    public int getReconnectInterval() {
+        return getConfigurationOrCreate().getReconnectInterval();
+    }
+
+    /**
+     * A custom ChannelHandler class that can be used to perform special marshalling of outbound payloads.
+     * @param encoder
+     */
+    public void setEncoder(ChannelHandler encoder) {
+        getConfigurationOrCreate().setEncoder(encoder);
+    }
+
+    public void setReconnectInterval(int reconnectInterval) {
+        getConfigurationOrCreate().setReconnectInterval(reconnectInterval);
+    }
+
+    public ChannelHandler getDecoder() {
+        return getConfigurationOrCreate().getDecoder();
+    }
+
+    /**
+     * A custom ChannelHandler class that can be used to perform special marshalling of inbound payloads.
+     * @param decoder
+     */
+    public void setDecoder(ChannelHandler decoder) {
+        getConfigurationOrCreate().setDecoder(decoder);
+    }
+
+    public boolean isDisconnect() {
+        return getConfigurationOrCreate().isDisconnect();
+    }
+
+    /**
+     * Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer.
+     * @param disconnect
+     */
+    public void setDisconnect(boolean disconnect) {
+        getConfigurationOrCreate().setDisconnect(disconnect);
+    }
+
+    public boolean isLazyChannelCreation() {
+        return getConfigurationOrCreate().isLazyChannelCreation();
+    }
+
+    /**
+     * Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started.
+     * @param lazyChannelCreation
+     */
+    public void setLazyChannelCreation(boolean lazyChannelCreation) {
+        getConfigurationOrCreate().setLazyChannelCreation(lazyChannelCreation);
+    }
+
+    public boolean isTransferExchange() {
+        return getConfigurationOrCreate().isTransferExchange();
+    }
+
+    /**
+     * 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.
+     * @param transferExchange
+     */
+    public void setTransferExchange(boolean transferExchange) {
+        getConfigurationOrCreate().setTransferExchange(transferExchange);
+    }
+
+    public boolean isDisconnectOnNoReply() {
+        return getConfigurationOrCreate().isDisconnectOnNoReply();
+    }
+
+    /**
+     * If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back.
+     * @param disconnectOnNoReply
+     */
+    public void setDisconnectOnNoReply(boolean disconnectOnNoReply) {
+        getConfigurationOrCreate().setDisconnectOnNoReply(disconnectOnNoReply);
+    }
+
+    public LoggingLevel getNoReplyLogLevel() {
+        return getConfigurationOrCreate().getNoReplyLogLevel();
+    }
+
+    /**
+     * If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back.
+     * @param noReplyLogLevel
+     */
+    public void setNoReplyLogLevel(LoggingLevel noReplyLogLevel) {
+        getConfigurationOrCreate().setNoReplyLogLevel(noReplyLogLevel);
+    }
+
+    public LoggingLevel getServerExceptionCaughtLogLevel() {
+        return getConfigurationOrCreate().getServerExceptionCaughtLogLevel();
+    }
+
+    /**
+     * If the server (NettyConsumer) catches an exception then its logged using this logging level.
+     * @param serverExceptionCaughtLogLevel
+     */
+    public void setServerExceptionCaughtLogLevel(LoggingLevel serverExceptionCaughtLogLevel) {
+        getConfigurationOrCreate().setServerExceptionCaughtLogLevel(serverExceptionCaughtLogLevel);
+    }
+
+    public LoggingLevel getServerClosedChannelExceptionCaughtLogLevel() {
+        return getConfigurationOrCreate().getServerClosedChannelExceptionCaughtLogLevel();
+    }
+
+    /**
+     * If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level.
+     * This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server.
+     * @param serverClosedChannelExceptionCaughtLogLevel
+     */
+    public void setServerClosedChannelExceptionCaughtLogLevel(LoggingLevel serverClosedChannelExceptionCaughtLogLevel) {
+        getConfigurationOrCreate().setServerClosedChannelExceptionCaughtLogLevel(serverClosedChannelExceptionCaughtLogLevel);
+    }
+
+    public boolean isAllowDefaultCodec() {
+        return getConfigurationOrCreate().isAllowDefaultCodec();
+    }
+
+    /**
+     * 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.
+     * @param allowDefaultCodec
+     */
+    public void setAllowDefaultCodec(boolean allowDefaultCodec) {
+        getConfigurationOrCreate().setAllowDefaultCodec(allowDefaultCodec);
+    }
+
+    public ClientInitializerFactory getClientInitializerFactory() {
+        return getConfigurationOrCreate().getClientInitializerFactory();
+    }
+
+    /**
+     * To use a custom ClientInitializerFactory
+     * @param clientInitializerFactory
+     */
+    public void setClientInitializerFactory(ClientInitializerFactory clientInitializerFactory) {
+        getConfigurationOrCreate().setClientInitializerFactory(clientInitializerFactory);
+    }
+
+    public boolean isUsingExecutorService() {
+        return getConfigurationOrCreate().isUsingExecutorService();
+    }
+
+    /**
+     * Whether to use ordered thread pool, to ensure events are processed orderly on the same channel.
+     * @param usingExecutorService
+     */
+    public void setUsingExecutorService(boolean usingExecutorService) {
+        getConfigurationOrCreate().setUsingExecutorService(usingExecutorService);
+    }
+
+    public int getProducerPoolMaxActive() {
+        return getConfigurationOrCreate().getProducerPoolMaxActive();
+    }
+
+    /**
+     * Sets the cap on the number of objects that can be allocated by the pool
+     * (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit.
+     * @param producerPoolMaxActive
+     */
+    public void setProducerPoolMaxActive(int producerPoolMaxActive) {
+        getConfigurationOrCreate().setProducerPoolMaxActive(producerPoolMaxActive);
+    }
+
+    public int getProducerPoolMinIdle() {
+        return getConfigurationOrCreate().getProducerPoolMinIdle();
+    }
+
+    /**
+     * Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects.
+     * @param producerPoolMinIdle
+     */
+    public void setProducerPoolMinIdle(int producerPoolMinIdle) {
+        getConfigurationOrCreate().setProducerPoolMinIdle(producerPoolMinIdle);
+    }
+
+    public int getProducerPoolMaxIdle() {
+        return getConfigurationOrCreate().getProducerPoolMaxIdle();
+    }
+
+    /**
+     * Sets the cap on the number of "idle" instances in the pool.
+     * @param producerPoolMaxIdle
+     */
+    public void setProducerPoolMaxIdle(int producerPoolMaxIdle) {
+        getConfigurationOrCreate().setProducerPoolMaxIdle(producerPoolMaxIdle);
+    }
+
+    public long getProducerPoolMinEvictableIdle() {
+        return getConfigurationOrCreate().getProducerPoolMinEvictableIdle();
+    }
+
+    /**
+     * Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor.
+     * @param producerPoolMinEvictableIdle
+     */
+    public void setProducerPoolMinEvictableIdle(long producerPoolMinEvictableIdle) {
+        getConfigurationOrCreate().setProducerPoolMinEvictableIdle(producerPoolMinEvictableIdle);
+    }
+
+    public boolean isProducerPoolEnabled() {
+        return getConfigurationOrCreate().isProducerPoolEnabled();
+    }
+
+    /**
+     * Whether producer pool is enabled or not.
+     * Important: Do not turn this off, as the pooling is needed for handling concurrency and reliable request/reply.
+     * @param producerPoolEnabled
+     */
+    public void setProducerPoolEnabled(boolean producerPoolEnabled) {
+        getConfigurationOrCreate().setProducerPoolEnabled(producerPoolEnabled);
+    }
+
+    public boolean isUdpConnectionlessSending() {
+        return getConfigurationOrCreate().isUdpConnectionlessSending();
+    }
+
+    /**
+     * This option supports connection less udp sending which is a real fire and forget.
+     * A connected udp send receive the PortUnreachableException if no one is listen on the receiving port.
+     * @param udpConnectionlessSending
+     */
+    public void setUdpConnectionlessSending(boolean udpConnectionlessSending) {
+        getConfigurationOrCreate().setUdpConnectionlessSending(udpConnectionlessSending);
+    }
+
+    public boolean isClientMode() {
+        return getConfigurationOrCreate().isClientMode();
+    }
+
+    /**
+     * If the clientMode is true, netty consumer will connect the address as a TCP client.
+     * @param clientMode
+     */
+    public void setClientMode(boolean clientMode) {
+        getConfigurationOrCreate().setClientMode(clientMode);
+    }
+
+    public boolean isUseByteBuf() {
+        return getConfigurationOrCreate().isUseByteBuf();
+    }
+
+    /**
+     * If the useByteBuf is true, netty producer will turn the message body into {@link ByteBuf} before sending it out.
+     * @param useByteBuf
+     */
+    public void setUseByteBuf(boolean useByteBuf) {
+        getConfigurationOrCreate().setUseByteBuf(useByteBuf);
+    }
+
+    public boolean isUdpByteArrayCodec() {
+        return getConfigurationOrCreate().isUdpByteArrayCodec();
+    }
+
+    /**
+     * For UDP only. If enabled the using byte array codec instead of Java serialization protocol.
+     * @param udpByteArrayCodec
+     */
+    public void setUdpByteArrayCodec(boolean udpByteArrayCodec) {
+        getConfigurationOrCreate().setUdpByteArrayCodec(udpByteArrayCodec);
+    }
+
+    public boolean isReuseChannel() {
+        return getConfigurationOrCreate().isReuseChannel();
+    }
+
+    /**
+     * This option allows producers to reuse the same Netty {@link Channel} for the lifecycle of processing the {@link Exchange}.
+     * This is useable 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
+     * 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}
+     * which allows you to obtain the channel during routing and use it as well.
+     * @param reuseChannel
+     */
+    public void setReuseChannel(boolean reuseChannel) {
+        getConfigurationOrCreate().setReuseChannel(reuseChannel);
+    }
 }

http://git-wip-us.apache.org/repos/asf/camel/blob/bdab2fc6/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java
----------------------------------------------------------------------
diff --git a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java
index 7bedf0d..0c1b3fc 100644
--- a/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java
+++ b/components/camel-netty4/src/main/java/org/apache/camel/component/netty4/springboot/NettyComponentConfiguration.java
@@ -16,8 +16,20 @@
  */
 package org.apache.camel.component.netty4.springboot;
 
+import java.util.List;
+import java.util.Map;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.group.ChannelGroup;
+import io.netty.handler.ssl.SslHandler;
 import io.netty.util.concurrent.EventExecutorGroup;
+import org.apache.camel.LoggingLevel;
+import org.apache.camel.component.netty4.ClientInitializerFactory;
 import org.apache.camel.component.netty4.NettyConfiguration;
+import org.apache.camel.component.netty4.NettyServerBootstrapFactory;
+import org.apache.camel.component.netty4.ServerInitializerFactory;
+import org.apache.camel.component.netty4.TextLineDelimiter;
+import org.apache.camel.util.jsse.SSLContextParameters;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
@@ -35,12 +47,362 @@ public class NettyComponentConfiguration {
     private Integer maximumPoolSize;
     /**
      * To use the NettyConfiguration as configuration when creating endpoints.
+     * Properties of the shared configuration can also be set individually.
      */
     private NettyConfiguration configuration;
     /**
      * To use the given EventExecutorGroup
      */
     private EventExecutorGroup executorService;
+    /**
+     * The protocol to use which can be tcp or udp.
+     */
+    private String protocol;
+    /**
+     * 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
+     */
+    private String host;
+    /**
+     * The host port number
+     */
+    private Integer port;
+    /**
+     * Setting to choose Multicast over UDP
+     */
+    private Boolean broadcast = false;
+    /**
+     * The TCP/UDP buffer sizes to be used during outbound communication. Size
+     * is bytes.
+     */
+    private Integer sendBufferSize;
+    /**
+     * The TCP/UDP buffer sizes to be used during inbound communication. Size is
+     * bytes.
+     */
+    private Integer receiveBufferSize;
+    /**
+     * Configures the buffer size predictor. See details at Jetty documentation
+     * and this mail thread.
+     */
+    private Integer receiveBufferSizePredictor;
+    /**
+     * 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
+     */
+    private Integer workerCount;
+    /**
+     * When netty works on nio mode it uses default bossCount parameter from
+     * Netty which is 1. User can use this operation to override the default
+     * bossCount from Netty
+     */
+    private Integer bossCount;
+    /**
+     * Setting to ensure socket is not closed due to inactivity
+     */
+    private Boolean keepAlive = false;
+    /**
+     * Setting to improve TCP protocol performance
+     */
+    private Boolean tcpNoDelay = false;
+    /**
+     * Setting to facilitate socket multiplexing
+     */
+    private Boolean reuseAddress = false;
+    /**
+     * Time to wait for a socket connection to be available. Value is in millis.
+     */
+    private Integer connectTimeout;
+    /**
+     * Allows to configure a backlog for netty consumer (server). Note the
+     * backlog is just a best effort depending on the OS. Setting this option to
+     * a value such as 200 500 or 1000 tells the TCP stack how long the accept
+     * queue can be If this option is not configured then the backlog depends on
+     * OS setting.
+     */
+    private Integer backlog;
+    /**
+     * Setting to specify whether SSL encryption is applied to this endpoint
+     */
+    private Boolean ssl = false;
+    /**
+     * When enabled and in SSL mode then the Netty consumer will enrich the
+     * Camel Message with headers having information about the client
+     * certificate such as subject name issuer name serial number and the valid
+     * date range.
+     */
+    private Boolean sslClientCertHeaders = false;
+    /**
+     * Reference to a class that could be used to return an SSL Handler
+     */
+    private SslHandler sslHandler;
+    /**
+     * To configure security using SSLContextParameters
+     */
+    private SSLContextParameters sslContextParameters;
+    /**
+     * Configures whether the server needs client authentication when using SSL.
+     */
+    private Boolean needClientAuth = false;
+    /**
+     * Client side certificate keystore to be used for encryption. Is loaded by
+     * default from classpath but you can prefix with classpath: file: or http:
+     * to load the resource from different systems.
+     */
+    private String keyStoreResource;
+    /**
+     * Server side certificate keystore to be used for encryption. Is loaded by
+     * default from classpath but you can prefix with classpath: file: or http:
+     * to load the resource from different systems.
+     */
+    private String trustStoreResource;
+    /**
+     * Keystore format to be used for payload encryption. Defaults to JKS if not
+     * set
+     */
+    private String keyStoreFormat;
+    /**
+     * Security provider to be used for payload encryption. Defaults to SunX509
+     * if not set.
+     */
+    private String securityProvider;
+    /**
+     * Password setting to use in order to encrypt/decrypt payloads sent using
+     * SSH
+     */
+    private String passphrase;
+    /**
+     * To use a custom ServerInitializerFactory
+     */
+    private ServerInitializerFactory serverInitializerFactory;
+    /**
+     * To use a custom NettyServerBootstrapFactory
+     */
+    private NettyServerBootstrapFactory nettyServerBootstrapFactory;
+    /**
+     * 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.
+     */
+    private long requestTimeout;
+    /**
+     * Setting to set endpoint as one-way or request-response
+     */
+    private Boolean sync = false;
+    /**
+     * Allows to configure additional netty options using option. as prefix. For
+     * example option.child.keepAlive=false to set the netty option
+     * child.keepAlive=false. See the Netty documentation for possible options
+     * that can be used.
+     */
+    private Map<String, Object> options;
+    /**
+     * Only used for TCP. If no codec is specified you can use this flag to
+     * indicate a text line based codec; if not specified or the value is false
+     * then Object Serialization is assumed over TCP.
+     */
+    private Boolean textline = false;
+    /**
+     * Whether to use native transport instead of NIO. Native transport takes
+     * advantage of the host operating system and is only supported on some
+     * platforms. You need to add the netty JAR for the host operating system
+     * you are using. See more details at:
+     * http://netty.io/wiki/native-transports.html
+     */
+    private Boolean nativeTransport = false;
+    /**
+     * The max line length to use for the textline codec.
+     */
+    private Integer decoderMaxLineLength;
+    /**
+     * Set the BossGroup which could be used for handling the new connection of
+     * the server side across the NettyEndpoint
+     */
+    private EventLoopGroup bossGroup;
+    /**
+     * The delimiter to use for the textline codec. Possible values are LINE and
+     * NULL.
+     */
+    private TextLineDelimiter delimiter;
+    /**
+     * Whether or not to auto append missing end delimiter when sending using
+     * the textline codec.
+     */
+    private Boolean autoAppendDelimiter = false;
+    /**
+     * To use a explicit EventLoopGroup as the boss thread pool. For example to
+     * share a thread pool with multiple consumers. By default each consumer has
+     * their own boss pool with 1 core thread.
+     */
+    private EventLoopGroup workerGroup;
+    /**
+     * To use a explicit ChannelGroup.
+     */
+    private ChannelGroup channelGroup;
+    /**
+     * The encoding (a charset name) to use for the textline codec. If not
+     * provided Camel will use the JVM default Charset.
+     */
+    private String encoding;
+    /**
+     * When using UDP then this option can be used to specify a network
+     * interface by its name such as eth0 to join a multicast group.
+     */
+    private String networkInterface;
+    /**
+     * A list of decoders to be used. You can use a String which have values
+     * separated by comma and have the values be looked up in the Registry. Just
+     * remember to prefix the value with so Camel knows it should lookup.
+     */
+    private List<ChannelHandler> decoders;
+    /**
+     * Which protocols to enable when using SSL
+     */
+    private String enabledProtocols;
+    /**
+     * A list of encoders to be used. You can use a String which have values
+     * separated by comma and have the values be looked up in the Registry. Just
+     * remember to prefix the value with so Camel knows it should lookup.
+     */
+    private List<ChannelHandler> encoders;
+    /**
+     * Used only in clientMode in consumer the consumer will attempt to
+     * reconnect on disconnection if this is enabled
+     */
+    private Boolean reconnect = false;
+    /**
+     * A custom ChannelHandler class that can be used to perform special
+     * marshalling of outbound payloads.
+     */
+    private ChannelHandler encoder;
+    /**
+     * Used if reconnect and clientMode is enabled. The interval in milli
+     * seconds to attempt reconnection
+     */
+    private Integer reconnectInterval;
+    /**
+     * A custom ChannelHandler class that can be used to perform special
+     * marshalling of inbound payloads.
+     */
+    private ChannelHandler decoder;
+    /**
+     * Whether or not to disconnect(close) from Netty Channel right after use.
+     * Can be used for both consumer and producer.
+     */
+    private Boolean disconnect = false;
+    /**
+     * Channels can be lazily created to avoid exceptions if the remote server
+     * is not up and running when the Camel producer is started.
+     */
+    private Boolean lazyChannelCreation = false;
+    /**
+     * 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.
+     */
+    private Boolean transferExchange = false;
+    /**
+     * If sync is enabled then this option dictates NettyConsumer if it should
+     * disconnect where there is no reply to send back.
+     */
+    private Boolean disconnectOnNoReply = false;
+    /**
+     * If sync is enabled this option dictates NettyConsumer which logging level
+     * to use when logging a there is no reply to send back.
+     */
+    private LoggingLevel noReplyLogLevel;
+    /**
+     * If the server (NettyConsumer) catches an exception then its logged using
+     * this logging level.
+     */
+    private LoggingLevel serverExceptionCaughtLogLevel;
+    /**
+     * If the server (NettyConsumer) catches an
+     * java.nio.channels.ClosedChannelException then its logged using this
+     * logging level. This is used to avoid logging the closed channel
+     * exceptions as clients can disconnect abruptly and then cause a flood of
+     * closed exceptions in the Netty server.
+     */
+    private LoggingLevel serverClosedChannelExceptionCaughtLogLevel;
+    /**
+     * 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.
+     */
+    private Boolean allowDefaultCodec = false;
+    /**
+     * To use a custom ClientInitializerFactory
+     */
+    private ClientInitializerFactory clientInitializerFactory;
+    /**
+     * Whether to use ordered thread pool to ensure events are processed orderly
+     * on the same channel.
+     */
+    private Boolean usingExecutorService = false;
+    /**
+     * Sets the cap on the number of objects that can be allocated by the pool
+     * (checked out to clients or idle awaiting checkout) at a given time. Use a
+     * negative value for no limit.
+     */
+    private Integer producerPoolMaxActive;
+    /**
+     * Sets the minimum number of instances allowed in the producer pool before
+     * the evictor thread (if active) spawns new objects.
+     */
+    private Integer producerPoolMinIdle;
+    /**
+     * Sets the cap on the number of idle instances in the pool.
+     */
+    private Integer producerPoolMaxIdle;
+    /**
+     * Sets the minimum amount of time (value in millis) an object may sit idle
+     * in the pool before it is eligible for eviction by the idle object
+     * evictor.
+     */
+    private long producerPoolMinEvictableIdle;
+    /**
+     * Whether producer pool is enabled or not. Important: Do not turn this off
+     * as the pooling is needed for handling concurrency and reliable
+     * request/reply.
+     */
+    private Boolean producerPoolEnabled = false;
+    /**
+     * This option supports connection less udp sending which is a real fire and
+     * forget. A connected udp send receive the PortUnreachableException if no
+     * one is listen on the receiving port.
+     */
+    private Boolean udpConnectionlessSending = false;
+    /**
+     * If the clientMode is true netty consumer will connect the address as a
+     * TCP client.
+     */
+    private Boolean clientMode = false;
+    /**
+     * If the useByteBuf is true netty producer will turn the message body into
+     * ByteBuf before sending it out.
+     */
+    private Boolean useByteBuf = false;
+    /**
+     * For UDP only. If enabled the using byte array codec instead of Java
+     * serialization protocol.
+     */
+    private Boolean udpByteArrayCodec = false;
+    /**
+     * This option allows producers to reuse the same Netty Channel for the
+     * lifecycle of processing the Exchange. This is useable 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
+     * exchange property with the key link NettyConstantsNETTY_CHANNEL which
+     * allows you to obtain the channel during routing and use it as well.
+     */
+    private Boolean reuseChannel = false;
 
     public Integer getMaximumPoolSize() {
         return maximumPoolSize;
@@ -65,4 +427,539 @@ public class NettyComponentConfiguration {
     public void setExecutorService(EventExecutorGroup executorService) {
         this.executorService = executorService;
     }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public void setProtocol(String protocol) {
+        this.protocol = protocol;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public Integer getPort() {
+        return port;
+    }
+
+    public void setPort(Integer port) {
+        this.port = port;
+    }
+
+    public Boolean getBroadcast() {
+        return broadcast;
+    }
+
+    public void setBroadcast(Boolean broadcast) {
+        this.broadcast = broadcast;
+    }
+
+    public Integer getSendBufferSize() {
+        return sendBufferSize;
+    }
+
+    public void setSendBufferSize(Integer sendBufferSize) {
+        this.sendBufferSize = sendBufferSize;
+    }
+
+    public Integer getReceiveBufferSize() {
+        return receiveBufferSize;
+    }
+
+    public void setReceiveBufferSize(Integer receiveBufferSize) {
+        this.receiveBufferSize = receiveBufferSize;
+    }
+
+    public Integer getReceiveBufferSizePredictor() {
+        return receiveBufferSizePredictor;
+    }
+
+    public void setReceiveBufferSizePredictor(Integer receiveBufferSizePredictor) {
+        this.receiveBufferSizePredictor = receiveBufferSizePredictor;
+    }
+
+    public Integer getWorkerCount() {
+        return workerCount;
+    }
+
+    public void setWorkerCount(Integer workerCount) {
+        this.workerCount = workerCount;
+    }
+
+    public Integer getBossCount() {
+        return bossCount;
+    }
+
+    public void setBossCount(Integer bossCount) {
+        this.bossCount = bossCount;
+    }
+
+    public Boolean getKeepAlive() {
+        return keepAlive;
+    }
+
+    public void setKeepAlive(Boolean keepAlive) {
+        this.keepAlive = keepAlive;
+    }
+
+    public Boolean getTcpNoDelay() {
+        return tcpNoDelay;
+    }
+
+    public void setTcpNoDelay(Boolean tcpNoDelay) {
+        this.tcpNoDelay = tcpNoDelay;
+    }
+
+    public Boolean getReuseAddress() {
+        return reuseAddress;
+    }
+
+    public void setReuseAddress(Boolean reuseAddress) {
+        this.reuseAddress = reuseAddress;
+    }
+
+    public Integer getConnectTimeout() {
+        return connectTimeout;
+    }
+
+    public void setConnectTimeout(Integer connectTimeout) {
+        this.connectTimeout = connectTimeout;
+    }
+
+    public Integer getBacklog() {
+        return backlog;
+    }
+
+    public void setBacklog(Integer backlog) {
+        this.backlog = backlog;
+    }
+
+    public Boolean getSsl() {
+        return ssl;
+    }
+
+    public void setSsl(Boolean ssl) {
+        this.ssl = ssl;
+    }
+
+    public Boolean getSslClientCertHeaders() {
+        return sslClientCertHeaders;
+    }
+
+    public void setSslClientCertHeaders(Boolean sslClientCertHeaders) {
+        this.sslClientCertHeaders = sslClientCertHeaders;
+    }
+
+    public SslHandler getSslHandler() {
+        return sslHandler;
+    }
+
+    public void setSslHandler(SslHandler sslHandler) {
+        this.sslHandler = sslHandler;
+    }
+
+    public SSLContextParameters getSslContextParameters() {
+        return sslContextParameters;
+    }
+
+    public void setSslContextParameters(
+            SSLContextParameters sslContextParameters) {
+        this.sslContextParameters = sslContextParameters;
+    }
+
+    public Boolean getNeedClientAuth() {
+        return needClientAuth;
+    }
+
+    public void setNeedClientAuth(Boolean needClientAuth) {
+        this.needClientAuth = needClientAuth;
+    }
+
+    public String getKeyStoreResource() {
+        return keyStoreResource;
+    }
+
+    public void setKeyStoreResource(String keyStoreResource) {
+        this.keyStoreResource = keyStoreResource;
+    }
+
+    public String getTrustStoreResource() {
+        return trustStoreResource;
+    }
+
+    public void setTrustStoreResource(String trustStoreResource) {
+        this.trustStoreResource = trustStoreResource;
+    }
+
+    public String getKeyStoreFormat() {
+        return keyStoreFormat;
+    }
+
+    public void setKeyStoreFormat(String keyStoreFormat) {
+        this.keyStoreFormat = keyStoreFormat;
+    }
+
+    public String getSecurityProvider() {
+        return securityProvider;
+    }
+
+    public void setSecurityProvider(String securityProvider) {
+        this.securityProvider = securityProvider;
+    }
+
+    public String getPassphrase() {
+        return passphrase;
+    }
+
+    public void setPassphrase(String passphrase) {
+        this.passphrase = passphrase;
+    }
+
+    public ServerInitializerFactory getServerInitializerFactory() {
+        return serverInitializerFactory;
+    }
+
+    public void setServerInitializerFactory(
+            ServerInitializerFactory serverInitializerFactory) {
+        this.serverInitializerFactory = serverInitializerFactory;
+    }
+
+    public NettyServerBootstrapFactory getNettyServerBootstrapFactory() {
+        return nettyServerBootstrapFactory;
+    }
+
+    public void setNettyServerBootstrapFactory(
+            NettyServerBootstrapFactory nettyServerBootstrapFactory) {
+        this.nettyServerBootstrapFactory = nettyServerBootstrapFactory;
+    }
+
+    public long getRequestTimeout() {
+        return requestTimeout;
+    }
+
+    public void setRequestTimeout(long requestTimeout) {
+        this.requestTimeout = requestTimeout;
+    }
+
+    public Boolean getSync() {
+        return sync;
+    }
+
+    public void setSync(Boolean sync) {
+        this.sync = sync;
+    }
+
+    public Map<String, Object> getOptions() {
+        return options;
+    }
+
+    public void setOptions(Map<String, Object> options) {
+        this.options = options;
+    }
+
+    public Boolean getTextline() {
+        return textline;
+    }
+
+    public void setTextline(Boolean textline) {
+        this.textline = textline;
+    }
+
+    public Boolean getNativeTransport() {
+        return nativeTransport;
+    }
+
+    public void setNativeTransport(Boolean nativeTransport) {
+        this.nativeTransport = nativeTransport;
+    }
+
+    public Integer getDecoderMaxLineLength() {
+        return decoderMaxLineLength;
+    }
+
+    public void setDecoderMaxLineLength(Integer decoderMaxLineLength) {
+        this.decoderMaxLineLength = decoderMaxLineLength;
+    }
+
+    public EventLoopGroup getBossGroup() {
+        return bossGroup;
+    }
+
+    public void setBossGroup(EventLoopGroup bossGroup) {
+        this.bossGroup = bossGroup;
+    }
+
+    public TextLineDelimiter getDelimiter() {
+        return delimiter;
+    }
+
+    public void setDelimiter(TextLineDelimiter delimiter) {
+        this.delimiter = delimiter;
+    }
+
+    public Boolean getAutoAppendDelimiter() {
+        return autoAppendDelimiter;
+    }
+
+    public void setAutoAppendDelimiter(Boolean autoAppendDelimiter) {
+        this.autoAppendDelimiter = autoAppendDelimiter;
+    }
+
+    public EventLoopGroup getWorkerGroup() {
+        return workerGroup;
+    }
+
+    public void setWorkerGroup(EventLoopGroup workerGroup) {
+        this.workerGroup = workerGroup;
+    }
+
+    public ChannelGroup getChannelGroup() {
+        return channelGroup;
+    }
+
+    public void setChannelGroup(ChannelGroup channelGroup) {
+        this.channelGroup = channelGroup;
+    }
+
+    public String getEncoding() {
+        return encoding;
+    }
+
+    public void setEncoding(String encoding) {
+        this.encoding = encoding;
+    }
+
+    public String getNetworkInterface() {
+        return networkInterface;
+    }
+
+    public void setNetworkInterface(String networkInterface) {
+        this.networkInterface = networkInterface;
+    }
+
+    public List<ChannelHandler> getDecoders() {
+        return decoders;
+    }
+
+    public void setDecoders(List<ChannelHandler> decoders) {
+        this.decoders = decoders;
+    }
+
+    public String getEnabledProtocols() {
+        return enabledProtocols;
+    }
+
+    public void setEnabledProtocols(String enabledProtocols) {
+        this.enabledProtocols = enabledProtocols;
+    }
+
+    public List<ChannelHandler> getEncoders() {
+        return encoders;
+    }
+
+    public void setEncoders(List<ChannelHandler> encoders) {
+        this.encoders = encoders;
+    }
+
+    public Boolean getReconnect() {
+        return reconnect;
+    }
+
+    public void setReconnect(Boolean reconnect) {
+        this.reconnect = reconnect;
+    }
+
+    public ChannelHandler getEncoder() {
+        return encoder;
+    }
+
+    public void setEncoder(ChannelHandler encoder) {
+        this.encoder = encoder;
+    }
+
+    public Integer getReconnectInterval() {
+        return reconnectInterval;
+    }
+
+    public void setReconnectInterval(Integer reconnectInterval) {
+        this.reconnectInterval = reconnectInterval;
+    }
+
+    public ChannelHandler getDecoder() {
+        return decoder;
+    }
+
+    public void setDecoder(ChannelHandler decoder) {
+        this.decoder = decoder;
+    }
+
+    public Boolean getDisconnect() {
+        return disconnect;
+    }
+
+    public void setDisconnect(Boolean disconnect) {
+        this.disconnect = disconnect;
+    }
+
+    public Boolean getLazyChannelCreation() {
+        return lazyChannelCreation;
+    }
+
+    public void setLazyChannelCreation(Boolean lazyChannelCreation) {
+        this.lazyChannelCreation = lazyChannelCreation;
+    }
+
+    public Boolean getTransferExchange() {
+        return transferExchange;
+    }
+
+    public void setTransferExchange(Boolean transferExchange) {
+        this.transferExchange = transferExchange;
+    }
+
+    public Boolean getDisconnectOnNoReply() {
+        return disconnectOnNoReply;
+    }
+
+    public void setDisconnectOnNoReply(Boolean disconnectOnNoReply) {
+        this.disconnectOnNoReply = disconnectOnNoReply;
+    }
+
+    public LoggingLevel getNoReplyLogLevel() {
+        return noReplyLogLevel;
+    }
+
+    public void setNoReplyLogLevel(LoggingLevel noReplyLogLevel) {
+        this.noReplyLogLevel = noReplyLogLevel;
+    }
+
+    public LoggingLevel getServerExceptionCaughtLogLevel() {
+        return serverExceptionCaughtLogLevel;
+    }
+
+    public void setServerExceptionCaughtLogLevel(
+            LoggingLevel serverExceptionCaughtLogLevel) {
+        this.serverExceptionCaughtLogLevel = serverExceptionCaughtLogLevel;
+    }
+
+    public LoggingLevel getServerClosedChannelExceptionCaughtLogLevel() {
+        return serverClosedChannelExceptionCaughtLogLevel;
+    }
+
+    public void setServerClosedChannelExceptionCaughtLogLevel(
+            LoggingLevel serverClosedChannelExceptionCaughtLogLevel) {
+        this.serverClosedChannelExceptionCaughtLogLevel = serverClosedChannelExceptionCaughtLogLevel;
+    }
+
+    public Boolean getAllowDefaultCodec() {
+        return allowDefaultCodec;
+    }
+
+    public void setAllowDefaultCodec(Boolean allowDefaultCodec) {
+        this.allowDefaultCodec = allowDefaultCodec;
+    }
+
+    public ClientInitializerFactory getClientInitializerFactory() {
+        return clientInitializerFactory;
+    }
+
+    public void setClientInitializerFactory(
+            ClientInitializerFactory clientInitializerFactory) {
+        this.clientInitializerFactory = clientInitializerFactory;
+    }
+
+    public Boolean getUsingExecutorService() {
+        return usingExecutorService;
+    }
+
+    public void setUsingExecutorService(Boolean usingExecutorService) {
+        this.usingExecutorService = usingExecutorService;
+    }
+
+    public Integer getProducerPoolMaxActive() {
+        return producerPoolMaxActive;
+    }
+
+    public void setProducerPoolMaxActive(Integer producerPoolMaxActive) {
+        this.producerPoolMaxActive = producerPoolMaxActive;
+    }
+
+    public Integer getProducerPoolMinIdle() {
+        return producerPoolMinIdle;
+    }
+
+    public void setProducerPoolMinIdle(Integer producerPoolMinIdle) {
+        this.producerPoolMinIdle = producerPoolMinIdle;
+    }
+
+    public Integer getProducerPoolMaxIdle() {
+        return producerPoolMaxIdle;
+    }
+
+    public void setProducerPoolMaxIdle(Integer producerPoolMaxIdle) {
+        this.producerPoolMaxIdle = producerPoolMaxIdle;
+    }
+
+    public long getProducerPoolMinEvictableIdle() {
+        return producerPoolMinEvictableIdle;
+    }
+
+    public void setProducerPoolMinEvictableIdle(
+            long producerPoolMinEvictableIdle) {
+        this.producerPoolMinEvictableIdle = producerPoolMinEvictableIdle;
+    }
+
+    public Boolean getProducerPoolEnabled() {
+        return producerPoolEnabled;
+    }
+
+    public void setProducerPoolEnabled(Boolean producerPoolEnabled) {
+        this.producerPoolEnabled = producerPoolEnabled;
+    }
+
+    public Boolean getUdpConnectionlessSending() {
+        return udpConnectionlessSending;
+    }
+
+    public void setUdpConnectionlessSending(Boolean udpConnectionlessSending) {
+        this.udpConnectionlessSending = udpConnectionlessSending;
+    }
+
+    public Boolean getClientMode() {
+        return clientMode;
+    }
+
+    public void setClientMode(Boolean clientMode) {
+        this.clientMode = clientMode;
+    }
+
+    public Boolean getUseByteBuf() {
+        return useByteBuf;
+    }
+
+    public void setUseByteBuf(Boolean useByteBuf) {
+        this.useByteBuf = useByteBuf;
+    }
+
+    public Boolean getUdpByteArrayCodec() {
+        return udpByteArrayCodec;
+    }
+
+    public void setUdpByteArrayCodec(Boolean udpByteArrayCodec) {
+        this.udpByteArrayCodec = udpByteArrayCodec;
+    }
+
+    public Boolean getReuseChannel() {
+        return reuseChannel;
+    }
+
+    public void setReuseChannel(Boolean reuseChannel) {
+        this.reuseChannel = reuseChannel;
+    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/camel/blob/bdab2fc6/components/camel-olingo2/camel-olingo2-component/src/main/docs/olingo2.adoc
----------------------------------------------------------------------
diff --git a/components/camel-olingo2/camel-olingo2-component/src/main/docs/olingo2.adoc b/components/camel-olingo2/camel-olingo2-component/src/main/docs/olingo2.adoc
index a124b7b..b062775 100644
--- a/components/camel-olingo2/camel-olingo2-component/src/main/docs/olingo2.adoc
+++ b/components/camel-olingo2/camel-olingo2-component/src/main/docs/olingo2.adoc
@@ -46,8 +46,9 @@ Olingo2 Options
 ^^^^^^^^^^^^^^^
 
 
+
 // component options: START
-The Olingo2 component supports 1 options which are listed below.
+The Olingo2 component supports 11 options which are listed below.
 
 
 
@@ -55,7 +56,17 @@ The Olingo2 component supports 1 options which are listed below.
 [width="100%",cols="2s,1m,8",options="header"]
 |=======================================================================
 | Name | Java Type | Description
-| configuration | Olingo2Configuration | To use the shared configuration
+| configuration | Olingo2Configuration | To use the shared configuration. Properties of the shared configuration can also be set individually.
+| apiName | Olingo2ApiName | What kind of operation to perform
+| methodName | String | What sub operation to use for the selected operation
+| serviceUri | String | Target OData service base URI e.g. http://services.odata.org/OData/OData.svc
+| contentType | String | Content-Type header value can be used to specify JSON or XML message format defaults to application/json;charset=utf-8
+| httpHeaders | Map | Custom HTTP headers to inject into every request this could include OAuth tokens etc.
+| connectTimeout | int | HTTP connection creation timeout in milliseconds defaults to 30000 (30 seconds)
+| socketTimeout | int | HTTP request timeout in milliseconds defaults to 30000 (30 seconds)
+| proxy | HttpHost | HTTP proxy server configuration
+| sslContextParameters | SSLContextParameters | To configure security using SSLContextParameters
+| httpAsyncClientBuilder | HttpAsyncClientBuilder | Custom HTTP async client builder for more complex HTTP client configuration overrides connectionTimeout socketTimeout proxy and sslContext. Note that a socketTimeout MUST be specified in the builder otherwise OData requests could block indefinitely
 |=======================================================================
 {% endraw %}
 // component options: END
@@ -63,6 +74,7 @@ The Olingo2 component supports 1 options which are listed below.
 
 
 
+
 // endpoint options: START
 The Olingo2 component supports 15 endpoint options which are listed below:
 

http://git-wip-us.apache.org/repos/asf/camel/blob/bdab2fc6/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/Olingo2Component.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/Olingo2Component.java b/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/Olingo2Component.java
index dd09fee..0a6a0e8 100644
--- a/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/Olingo2Component.java
+++ b/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/Olingo2Component.java
@@ -92,7 +92,7 @@ public class Olingo2Component extends AbstractApiComponent<Olingo2ApiName, Oling
     }
 
     /**
-     * To use the shared configuration
+     * To use the shared configuration. Properties of the shared configuration can also be set individually.
      */
     @Override
     public void setConfiguration(Olingo2Configuration configuration) {
@@ -175,4 +175,132 @@ public class Olingo2Component extends AbstractApiComponent<Olingo2ApiName, Oling
             apiProxy.close();
         }
     }
+
+    private Olingo2Configuration getConfigurationOrCreate() {
+        if (this.getConfiguration() == null) {
+            this.setConfiguration(new Olingo2Configuration());
+        }
+        return this.getConfiguration();
+    }
+
+    public Olingo2ApiName getApiName() {
+        return getConfigurationOrCreate().getApiName();
+    }
+
+    /**
+     * What kind of operation to perform
+     * @param apiName
+     */
+    public void setApiName(Olingo2ApiName apiName) {
+        getConfigurationOrCreate().setApiName(apiName);
+    }
+
+    public String getMethodName() {
+        return getConfigurationOrCreate().getMethodName();
+    }
+
+    /**
+     * What sub operation to use for the selected operation
+     * @param methodName
+     */
+    public void setMethodName(String methodName) {
+        getConfigurationOrCreate().setMethodName(methodName);
+    }
+
+    public String getServiceUri() {
+        return getConfigurationOrCreate().getServiceUri();
+    }
+
+    /**
+     * Target OData service base URI, e.g. http://services.odata.org/OData/OData.svc
+     * @param serviceUri
+     */
+    public void setServiceUri(String serviceUri) {
+        getConfigurationOrCreate().setServiceUri(serviceUri);
+    }
+
+    public String getContentType() {
+        return getConfigurationOrCreate().getContentType();
+    }
+
+    /**
+     * Content-Type header value can be used to specify JSON or XML message format, defaults to application/json;charset=utf-8
+     * @param contentType
+     */
+    public void setContentType(String contentType) {
+        getConfigurationOrCreate().setContentType(contentType);
+    }
+
+    public Map<String, String> getHttpHeaders() {
+        return getConfigurationOrCreate().getHttpHeaders();
+    }
+
+    /**
+     * Custom HTTP headers to inject into every request, this could include OAuth tokens, etc.
+     * @param httpHeaders
+     */
+    public void setHttpHeaders(Map<String, String> httpHeaders) {
+        getConfigurationOrCreate().setHttpHeaders(httpHeaders);
+    }
+
+    public int getConnectTimeout() {
+        return getConfigurationOrCreate().getConnectTimeout();
+    }
+
+    /**
+     * HTTP connection creation timeout in milliseconds, defaults to 30,000 (30 seconds)
+     * @param connectTimeout
+     */
+    public void setConnectTimeout(int connectTimeout) {
+        getConfigurationOrCreate().setConnectTimeout(connectTimeout);
+    }
+
+    public int getSocketTimeout() {
+        return getConfigurationOrCreate().getSocketTimeout();
+    }
+
+    /**
+     * HTTP request timeout in milliseconds, defaults to 30,000 (30 seconds)
+     * @param socketTimeout
+     */
+    public void setSocketTimeout(int socketTimeout) {
+        getConfigurationOrCreate().setSocketTimeout(socketTimeout);
+    }
+
+    public HttpHost getProxy() {
+        return getConfigurationOrCreate().getProxy();
+    }
+
+    /**
+     * HTTP proxy server configuration
+     * @param proxy
+     */
+    public void setProxy(HttpHost proxy) {
+        getConfigurationOrCreate().setProxy(proxy);
+    }
+
+    public SSLContextParameters getSslContextParameters() {
+        return getConfigurationOrCreate().getSslContextParameters();
+    }
+
+    /**
+     * To configure security using SSLContextParameters
+     * @param sslContextParameters
+     */
+    public void setSslContextParameters(SSLContextParameters sslContextParameters) {
+        getConfigurationOrCreate().setSslContextParameters(sslContextParameters);
+    }
+
+    public HttpAsyncClientBuilder getHttpAsyncClientBuilder() {
+        return getConfigurationOrCreate().getHttpAsyncClientBuilder();
+    }
+
+    /**
+     * Custom HTTP async client builder for more complex HTTP client configuration, overrides connectionTimeout, socketTimeout, proxy and sslContext.
+     * Note that a socketTimeout MUST be specified in the builder, otherwise OData requests could block indefinitely
+     * @param httpAsyncClientBuilder
+     */
+    public void setHttpAsyncClientBuilder(HttpAsyncClientBuilder httpAsyncClientBuilder) {
+        getConfigurationOrCreate().setHttpAsyncClientBuilder(httpAsyncClientBuilder);
+    }
 }

http://git-wip-us.apache.org/repos/asf/camel/blob/bdab2fc6/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/springboot/Olingo2ComponentConfiguration.java
----------------------------------------------------------------------
diff --git a/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/springboot/Olingo2ComponentConfiguration.java b/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/springboot/Olingo2ComponentConfiguration.java
index 037baa4..733892e 100644
--- a/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/springboot/Olingo2ComponentConfiguration.java
+++ b/components/camel-olingo2/camel-olingo2-component/src/main/java/org/apache/camel/component/olingo2/springboot/Olingo2ComponentConfiguration.java
@@ -16,7 +16,12 @@
  */
 package org.apache.camel.component.olingo2.springboot;
 
+import java.util.Map;
 import org.apache.camel.component.olingo2.Olingo2Configuration;
+import org.apache.camel.component.olingo2.internal.Olingo2ApiName;
+import org.apache.camel.util.jsse.SSLContextParameters;
+import org.apache.http.HttpHost;
+import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
@@ -28,9 +33,57 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
 public class Olingo2ComponentConfiguration {
 
     /**
-     * To use the shared configuration
+     * To use the shared configuration. Properties of the shared configuration
+     * can also be set individually.
      */
     private Olingo2Configuration configuration;
+    /**
+     * What kind of operation to perform
+     */
+    private Olingo2ApiName apiName;
+    /**
+     * What sub operation to use for the selected operation
+     */
+    private String methodName;
+    /**
+     * Target OData service base URI e.g.
+     * http://services.odata.org/OData/OData.svc
+     */
+    private String serviceUri;
+    /**
+     * Content-Type header value can be used to specify JSON or XML message
+     * format defaults to application/json;charset=utf-8
+     */
+    private String contentType;
+    /**
+     * Custom HTTP headers to inject into every request this could include OAuth
+     * tokens etc.
+     */
+    private Map<String, String> httpHeaders;
+    /**
+     * HTTP connection creation timeout in milliseconds defaults to 30000 (30
+     * seconds)
+     */
+    private Integer connectTimeout;
+    /**
+     * HTTP request timeout in milliseconds defaults to 30000 (30 seconds)
+     */
+    private Integer socketTimeout;
+    /**
+     * HTTP proxy server configuration
+     */
+    private HttpHost proxy;
+    /**
+     * To configure security using SSLContextParameters
+     */
+    private SSLContextParameters sslContextParameters;
+    /**
+     * Custom HTTP async client builder for more complex HTTP client
+     * configuration overrides connectionTimeout socketTimeout proxy and
+     * sslContext. Note that a socketTimeout MUST be specified in the builder
+     * otherwise OData requests could block indefinitely
+     */
+    private HttpAsyncClientBuilder httpAsyncClientBuilder;
 
     public Olingo2Configuration getConfiguration() {
         return configuration;
@@ -39,4 +92,86 @@ public class Olingo2ComponentConfiguration {
     public void setConfiguration(Olingo2Configuration configuration) {
         this.configuration = configuration;
     }
+
+    public Olingo2ApiName getApiName() {
+        return apiName;
+    }
+
+    public void setApiName(Olingo2ApiName apiName) {
+        this.apiName = apiName;
+    }
+
+    public String getMethodName() {
+        return methodName;
+    }
+
+    public void setMethodName(String methodName) {
+        this.methodName = methodName;
+    }
+
+    public String getServiceUri() {
+        return serviceUri;
+    }
+
+    public void setServiceUri(String serviceUri) {
+        this.serviceUri = serviceUri;
+    }
+
+    public String getContentType() {
+        return contentType;
+    }
+
+    public void setContentType(String contentType) {
+        this.contentType = contentType;
+    }
+
+    public Map<String, String> getHttpHeaders() {
+        return httpHeaders;
+    }
+
+    public void setHttpHeaders(Map<String, String> httpHeaders) {
+        this.httpHeaders = httpHeaders;
+    }
+
+    public Integer getConnectTimeout() {
+        return connectTimeout;
+    }
+
+    public void setConnectTimeout(Integer connectTimeout) {
+        this.connectTimeout = connectTimeout;
+    }
+
+    public Integer getSocketTimeout() {
+        return socketTimeout;
+    }
+
+    public void setSocketTimeout(Integer socketTimeout) {
+        this.socketTimeout = socketTimeout;
+    }
+
+    public HttpHost getProxy() {
+        return proxy;
+    }
+
+    public void setProxy(HttpHost proxy) {
+        this.proxy = proxy;
+    }
+
+    public SSLContextParameters getSslContextParameters() {
+        return sslContextParameters;
+    }
+
+    public void setSslContextParameters(
+            SSLContextParameters sslContextParameters) {
+        this.sslContextParameters = sslContextParameters;
+    }
+
+    public HttpAsyncClientBuilder getHttpAsyncClientBuilder() {
+        return httpAsyncClientBuilder;
+    }
+
+    public void setHttpAsyncClientBuilder(
+            HttpAsyncClientBuilder httpAsyncClientBuilder) {
+        this.httpAsyncClientBuilder = httpAsyncClientBuilder;
+    }
 }
\ No newline at end of file


Mime
View raw message