camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject [02/11] camel git commit: CAMEL-10197: Source check
Date Tue, 02 Aug 2016 06:43:30 GMT
http://git-wip-us.apache.org/repos/asf/camel/blob/519765f8/components/camel-netty4-http/src/main/java/org/apache/camel/component/netty4/http/springboot/NettyHttpComponentConfiguration.java
----------------------------------------------------------------------
diff --git a/components/camel-netty4-http/src/main/java/org/apache/camel/component/netty4/http/springboot/NettyHttpComponentConfiguration.java
b/components/camel-netty4-http/src/main/java/org/apache/camel/component/netty4/http/springboot/NettyHttpComponentConfiguration.java
index e1a21a2..8acc6b7 100644
--- a/components/camel-netty4-http/src/main/java/org/apache/camel/component/netty4/http/springboot/NettyHttpComponentConfiguration.java
+++ b/components/camel-netty4-http/src/main/java/org/apache/camel/component/netty4/http/springboot/NettyHttpComponentConfiguration.java
@@ -16,11 +16,23 @@
  */
 package org.apache.camel.component.netty4.http.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.component.netty4.http.NettyHttpBinding;
 import org.apache.camel.component.netty4.http.NettyHttpSecurityConfiguration;
 import org.apache.camel.spi.HeaderFilterStrategy;
+import org.apache.camel.util.jsse.SSLContextParameters;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
@@ -54,12 +66,362 @@ public class NettyHttpComponentConfiguration {
     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 NettyHttpBinding getNettyHttpBinding() {
         return nettyHttpBinding;
@@ -110,4 +472,539 @@ public class NettyHttpComponentConfiguration {
     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/519765f8/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/DefaultUndertowHttpBinding.java
----------------------------------------------------------------------
diff --git a/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/DefaultUndertowHttpBinding.java
b/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/DefaultUndertowHttpBinding.java
index f8a90ea..a0bd90b 100644
--- a/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/DefaultUndertowHttpBinding.java
+++ b/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/DefaultUndertowHttpBinding.java
@@ -81,14 +81,14 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
     }
 
     public Boolean isTransferException() {
-		return transferException;
-	}
+        return transferException;
+    }
 
-	public void setTransferException(Boolean transferException) {
-		this.transferException = transferException;
-	}
+    public void setTransferException(Boolean transferException) {
+        this.transferException = transferException;
+    }
 
-	@Override
+    @Override
     public Message toCamelMessage(HttpServerExchange httpExchange, Exchange exchange) throws
Exception {
         Message result = new DefaultMessage();
 
@@ -160,7 +160,7 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
                 // store a special header that this request was authenticated using HTTP
Basic
                 if (value != null && value.trim().startsWith("Basic")) {
                     if (headerFilterStrategy != null
-                        && !headerFilterStrategy.applyFilterToExternalHeaders(Exchange.AUTHENTICATION,
"Basic", exchange)) {
+                            && !headerFilterStrategy.applyFilterToExternalHeaders(Exchange.AUTHENTICATION,
"Basic", exchange)) {
                         UndertowHelper.appendHeader(headersMap, Exchange.AUTHENTICATION,
"Basic");
                     }
                 }
@@ -172,7 +172,7 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
                 Object value = it.next();
                 LOG.trace("HTTP-header: {}", value);
                 if (headerFilterStrategy != null
-                    && !headerFilterStrategy.applyFilterToExternalHeaders(name.toString(),
value, exchange)) {
+                        && !headerFilterStrategy.applyFilterToExternalHeaders(name.toString(),
value, exchange)) {
                     UndertowHelper.appendHeader(headersMap, name.toString(), value);
                 }
             }
@@ -191,7 +191,7 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
                     Object value = it.next();
                     LOG.trace("URI-Parameter: {}", value);
                     if (headerFilterStrategy != null
-                        && !headerFilterStrategy.applyFilterToExternalHeaders(name,
value, exchange)) {
+                            && !headerFilterStrategy.applyFilterToExternalHeaders(name,
value, exchange)) {
                         UndertowHelper.appendHeader(headersMap, name, value);
                     }
                 }
@@ -229,7 +229,7 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
                 // store a special header that this request was authenticated using HTTP
Basic
                 if (value != null && value.trim().startsWith("Basic")) {
                     if (headerFilterStrategy != null
-                        && !headerFilterStrategy.applyFilterToExternalHeaders(Exchange.AUTHENTICATION,
"Basic", exchange)) {
+                            && !headerFilterStrategy.applyFilterToExternalHeaders(Exchange.AUTHENTICATION,
"Basic", exchange)) {
                         UndertowHelper.appendHeader(headersMap, Exchange.AUTHENTICATION,
"Basic");
                     }
                 }
@@ -241,7 +241,7 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
                 Object value = it.next();
                 LOG.trace("HTTP-header: {}", value);
                 if (headerFilterStrategy != null
-                    && !headerFilterStrategy.applyFilterToExternalHeaders(name.toString(),
value, exchange)) {
+                        && !headerFilterStrategy.applyFilterToExternalHeaders(name.toString(),
value, exchange)) {
                     UndertowHelper.appendHeader(headersMap, name.toString(), value);
                 }
             }
@@ -268,7 +268,7 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
             while (it.hasNext()) {
                 String headerValue = tc.convertTo(String.class, it.next());
                 if (headerValue != null && headerFilterStrategy != null
-                    && !headerFilterStrategy.applyFilterToCamelHeaders(key, headerValue,
message.getExchange())) {
+                        && !headerFilterStrategy.applyFilterToCamelHeaders(key, headerValue,
message.getExchange())) {
                     LOG.trace("HTTP-Header: {}={}", key, headerValue);
                     httpExchange.getResponseHeaders().add(new HttpString(key), headerValue);
                 }
@@ -342,7 +342,7 @@ public class DefaultUndertowHttpBinding implements UndertowHttpBinding
{
             while (it.hasNext()) {
                 String headerValue = tc.convertTo(String.class, it.next());
                 if (headerValue != null && headerFilterStrategy != null
-                    && !headerFilterStrategy.applyFilterToCamelHeaders(key, headerValue,
message.getExchange())) {
+                        && !headerFilterStrategy.applyFilterToCamelHeaders(key, headerValue,
message.getExchange())) {
                     LOG.trace("HTTP-Header: {}={}", key, headerValue);
                     clientRequest.getRequestHeaders().add(new HttpString(key), headerValue);
                 }

http://git-wip-us.apache.org/repos/asf/camel/blob/519765f8/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/UndertowComponent.java
----------------------------------------------------------------------
diff --git a/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/UndertowComponent.java
b/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/UndertowComponent.java
index 912856f..deeb6f3 100644
--- a/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/UndertowComponent.java
+++ b/components/camel-undertow/src/main/java/org/apache/camel/component/undertow/UndertowComponent.java
@@ -32,6 +32,7 @@ import io.undertow.predicate.Predicate;
 import io.undertow.predicate.Predicates;
 import io.undertow.server.handlers.PathHandler;
 import io.undertow.server.handlers.PredicateHandler;
+
 import org.apache.camel.CamelContext;
 import org.apache.camel.Consumer;
 import org.apache.camel.Endpoint;
@@ -94,14 +95,14 @@ public class UndertowComponent extends UriEndpointComponent implements
RestConsu
 
         // then re-create the http uri with the remaining parameters which the endpoint did
not use
         URI httpUri = URISupport.createRemainingURI(
-            new URI(uriHttpUriAddress.getScheme(),
-                uriHttpUriAddress.getUserInfo(),
-                uriHttpUriAddress.getHost(),
-                uriHttpUriAddress.getPort(),
-                uriHttpUriAddress.getPath(),
-                uriHttpUriAddress.getQuery(),
-                uriHttpUriAddress.getFragment()),
-            parameters);
+                new URI(uriHttpUriAddress.getScheme(),
+                        uriHttpUriAddress.getUserInfo(),
+                        uriHttpUriAddress.getHost(),
+                        uriHttpUriAddress.getPort(),
+                        uriHttpUriAddress.getPath(),
+                        uriHttpUriAddress.getQuery(),
+                        uriHttpUriAddress.getFragment()),
+                parameters);
         endpoint.setHttpURI(httpUri);
 
         return endpoint;


Mime
View raw message