You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2018/03/09 11:16:37 UTC
[camel] branch master updated: CAMEL-12330: Allow to configure more
option on rabbitmq component level.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/master by this push:
new eba3689 CAMEL-12330: Allow to configure more option on rabbitmq component level.
eba3689 is described below
commit eba3689dd12a7ed48e52bc7063434f9d309e402a
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Mar 9 11:05:04 2018 +0100
CAMEL-12330: Allow to configure more option on rabbitmq component level.
---
.../src/main/docs/rabbitmq-component.adoc | 38 +-
.../component/rabbitmq/RabbitMQComponent.java | 467 ++++++++++++++++++++-
.../camel/component/rabbitmq/RabbitMQEndpoint.java | 32 +-
.../springboot/RabbitMQComponentConfiguration.java | 378 +++++++++++++++++
4 files changed, 887 insertions(+), 28 deletions(-)
diff --git a/components/camel-rabbitmq/src/main/docs/rabbitmq-component.adoc b/components/camel-rabbitmq/src/main/docs/rabbitmq-component.adoc
index 30eca55..ff585ad 100644
--- a/components/camel-rabbitmq/src/main/docs/rabbitmq-component.adoc
+++ b/components/camel-rabbitmq/src/main/docs/rabbitmq-component.adoc
@@ -47,7 +47,7 @@ exchange name determines which exchange the queue will bind to.
=== Options
// component options: START
-The RabbitMQ component supports 7 options which are listed below.
+The RabbitMQ component supports 35 options which are listed below.
@@ -58,8 +58,36 @@ The RabbitMQ component supports 7 options which are listed below.
| *portNumber* (common) | Port number for the host with the running rabbitmq instance or cluster. | 5672 | int
| *username* (security) | Username in case of authenticated access | guest | String
| *password* (security) | Password for authenticated access | guest | String
+| *vhost* (common) | The vhost for the channel | / | String
+| *addresses* (common) | If this option is set, camel-rabbitmq will try to create connection based on the setting of option addresses. The addresses value is a string which looks like server1:12345, server2:12345 | | String
| *connectionFactory* (common) | To use a custom RabbitMQ connection factory. When this option is set, all connection options (connectionTimeout, requestedChannelMax...) set on URI are not used | | ConnectionFactory
-| *autoDetectConnection Factory* (common) | Whether to auto-detect looking up RabbitMQ connection factory from the registry. When enabled and a single instance of the connection factory is found then it will be used. An explicit connection factory can be configured on the component or endpoint level which takes precedence. | true | boolean
+| *threadPoolSize* (consumer) | The consumer uses a Thread Pool Executor with a fixed number of threads. This setting allows you to set that number of threads. | 10 | int
+| *autoDetectConnection Factory* (advanced) | Whether to auto-detect looking up RabbitMQ connection factory from the registry. When enabled and a single instance of the connection factory is found then it will be used. An explicit connection factory can be configured on the component or endpoint level which takes precedence. | true | boolean
+| *connectionTimeout* (advanced) | Connection timeout | 60000 | int
+| *requestedChannelMax* (advanced) | Connection requested channel max (max number of channels offered) | 0 | int
+| *requestedFrameMax* (advanced) | Connection requested frame max (max size of frame offered) | 0 | int
+| *requestedHeartbeat* (advanced) | Connection requested heartbeat (heart-beat in seconds offered) | 60 | int
+| *automaticRecovery Enabled* (advanced) | Enables connection automatic recovery (uses connection implementation that performs automatic recovery when connection shutdown is not initiated by the application) | | Boolean
+| *networkRecoveryInterval* (advanced) | Network recovery interval in milliseconds (interval used when recovering from network failure) | 5000 | Integer
+| *topologyRecoveryEnabled* (advanced) | Enables connection topology recovery (should topology recovery be performed) | | Boolean
+| *prefetchEnabled* (consumer) | Enables the quality of service on the RabbitMQConsumer side. You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time | false | boolean
+| *prefetchSize* (consumer) | The maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited. You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time | | int
+| *prefetchCount* (consumer) | The maximum number of messages that the server will deliver, 0 if unlimited. You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time | | int
+| *prefetchGlobal* (consumer) | If the settings should be applied to the entire channel rather than each consumer You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time | false | boolean
+| *channelPoolMaxSize* (producer) | Get maximum number of opened channel in pool | 10 | int
+| *channelPoolMaxWait* (producer) | Set the maximum number of milliseconds to wait for a channel from the pool | 1000 | long
+| *requestTimeout* (advanced) | Set timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds) | 20000 | long
+| *requestTimeoutChecker Interval* (advanced) | Set requestTimeoutCheckerInterval for inOut exchange | 1000 | long
+| *transferException* (advanced) | When true and an inOut Exchange failed on the consumer side send the caused Exception back in the response | false | boolean
+| *publisher Acknowledgements* (producer) | When true, the message will be published with publisher acknowledgements turned on | false | boolean
+| *publisher AcknowledgementsTimeout* (producer) | The amount of time in milliseconds to wait for a basic.ack response from RabbitMQ server | | long
+| *guaranteedDeliveries* (producer) | When true, an exception will be thrown when the message cannot be delivered (basic.return) and the message is marked as mandatory. PublisherAcknowledgement will also be activated in this case. See also publisher acknowledgements - When will messages be confirmed. | false | boolean
+| *mandatory* (producer) | This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message. If the header is present rabbitmq.MANDATORY it will override this option. | false | boolean
+| *immediate* (producer) | This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed. If the header is present rabbitmq.IMMEDIATE it will override this option. | false | boolean
+| *args* (advanced) | Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each: Exchange: arg.exchange. Queue: arg.queue. Binding: arg.binding. For example to declare a queue with message ttl argument: http://localhost:5672/exchange/queueargs=arg.queue.x-message-ttl=60000 | | Map
+| *clientProperties* (advanced) | Connection client properties (client info used in negotiating with the server) | | Map
+| *sslProtocol* (common) | Enables SSL on connection, accepted value are true, TLS and 'SSLv3 | | String
+| *trustManager* (common) | Configure SSL trust manager, SSL should be enabled for this option to be effective | | TrustManager
| *resolveProperty Placeholders* (advanced) | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | boolean
|===
// component options: END
@@ -90,9 +118,9 @@ with the following path and query parameters:
[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
+| *addresses* (common) | If this option is set, camel-rabbitmq will try to create connection based on the setting of option addresses. The addresses value is a string which looks like server1:12345, server2:12345 | | Address[]
| *autoDelete* (common) | If it is true, the exchange will be deleted when it is no longer in use | true | boolean
| *connectionFactory* (common) | To use a custom RabbitMQ connection factory. When this option is set, all connection options (connectionTimeout, requestedChannelMax...) set on URI are not used | | ConnectionFactory
-| *connectionTimeout* (common) | Connection timeout | 60000 | int
| *deadLetterExchange* (common) | The name of the dead letter exchange | | String
| *deadLetterExchangeType* (common) | The type of the dead letter exchange | direct | String
| *deadLetterQueue* (common) | The name of the dead letter queue | | String
@@ -123,16 +151,16 @@ with the following path and query parameters:
| *bridgeEndpoint* (producer) | If the bridgeEndpoint is true, the producer will ignore the message header of rabbitmq.EXCHANGE_NAME and rabbitmq.ROUTING_KEY | false | boolean
| *channelPoolMaxSize* (producer) | Get maximum number of opened channel in pool | 10 | int
| *channelPoolMaxWait* (producer) | Set the maximum number of milliseconds to wait for a channel from the pool | 1000 | long
-| *guaranteedDeliveries* (producer) | When true, an exception will be thrown when the message cannot be delivered (basic.return) and the message is marked as mandatory. PublisherAcknowledgement will also be activated in this case See also a href=https://www.rabbitmq.com/confirms.htmlpublisher acknowledgements - When will messages be confirmed | false | boolean
+| *guaranteedDeliveries* (producer) | When true, an exception will be thrown when the message cannot be delivered (basic.return) and the message is marked as mandatory. PublisherAcknowledgement will also be activated in this case. See also publisher acknowledgements - When will messages be confirmed. | false | boolean
| *immediate* (producer) | This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed. If the header is present rabbitmq.IMMEDIATE it will override this option. | false | boolean
| *mandatory* (producer) | This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message. If the header is present rabbitmq.MANDATORY it will override this option. | false | boolean
| *publisherAcknowledgements* (producer) | When true, the message will be published with publisher acknowledgements turned on | false | boolean
| *publisherAcknowledgements Timeout* (producer) | The amount of time in milliseconds to wait for a basic.ack response from RabbitMQ server | | long
-| *addresses* (advanced) | If this option is set, camel-rabbitmq will try to create connection based on the setting of option addresses. The addresses value is a string which looks like server1:12345, server2:12345 | | Address[]
| *args* (advanced) | Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each: Exchange: arg.exchange. Queue: arg.queue. Binding: arg.binding. For example to declare a queue with message ttl argument: http://localhost:5672/exchange/queueargs=arg.queue.x-message-ttl=60000 | | Map
| *automaticRecoveryEnabled* (advanced) | Enables connection automatic recovery (uses connection implementation that performs automatic recovery when connection shutdown is not initiated by the application) | | Boolean
| *bindingArgs* (advanced) | *Deprecated* Key/value args for configuring the queue binding parameters when declare=true | | Map
| *clientProperties* (advanced) | Connection client properties (client info used in negotiating with the server) | | Map
+| *connectionTimeout* (advanced) | Connection timeout | 60000 | int
| *exchangeArgs* (advanced) | *Deprecated* Key/value args for configuring the exchange parameters when declare=true | | Map
| *exchangeArgsConfigurer* (advanced) | *Deprecated* Set the configurer for setting the exchange args in Channel.exchangeDeclare | | ArgsConfigurer
| *networkRecoveryInterval* (advanced) | Network recovery interval in milliseconds (interval used when recovering from network failure) | 5000 | Integer
diff --git a/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQComponent.java b/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQComponent.java
index d17fef4..05eb8d1 100644
--- a/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQComponent.java
+++ b/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQComponent.java
@@ -18,15 +18,15 @@ package org.apache.camel.component.rabbitmq;
import java.net.URI;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.Map;
-import java.util.Set;
import javax.net.ssl.TrustManager;
+import com.rabbitmq.client.Address;
import com.rabbitmq.client.ConnectionFactory;
import org.apache.camel.CamelContext;
import org.apache.camel.impl.UriEndpointComponent;
import org.apache.camel.spi.Metadata;
+import org.apache.camel.spi.UriParam;
import org.apache.camel.util.IntrospectionSupport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -48,10 +48,66 @@ public class RabbitMQComponent extends UriEndpointComponent {
private String username = ConnectionFactory.DEFAULT_USER;
@Metadata(label = "security", defaultValue = ConnectionFactory.DEFAULT_PASS, secret = true)
private String password = ConnectionFactory.DEFAULT_PASS;
+ @Metadata(label = "common", defaultValue = ConnectionFactory.DEFAULT_VHOST)
+ private String vhost = ConnectionFactory.DEFAULT_VHOST;
+ @Metadata(label = "common")
+ private Address[] addresses;
@Metadata(label = "common")
private ConnectionFactory connectionFactory;
- @Metadata(label = "common", defaultValue = "true")
+ @UriParam(label = "security")
+ private String sslProtocol;
+ @UriParam(label = "security")
+ private TrustManager trustManager;
+ @Metadata(label = "consumer,advanced", defaultValue = "10")
+ private int threadPoolSize = 10;
+ @Metadata(label = "advanced", defaultValue = "true")
private boolean autoDetectConnectionFactory = true;
+ @Metadata(label = "advanced", defaultValue = "" + ConnectionFactory.DEFAULT_CONNECTION_TIMEOUT)
+ private int connectionTimeout = ConnectionFactory.DEFAULT_CONNECTION_TIMEOUT;
+ @Metadata(label = "advanced", defaultValue = "" + ConnectionFactory.DEFAULT_CHANNEL_MAX)
+ private int requestedChannelMax = ConnectionFactory.DEFAULT_CHANNEL_MAX;
+ @Metadata(label = "advanced", defaultValue = "" + ConnectionFactory.DEFAULT_FRAME_MAX)
+ private int requestedFrameMax = ConnectionFactory.DEFAULT_FRAME_MAX;
+ @Metadata(label = "advanced", defaultValue = "" + ConnectionFactory.DEFAULT_HEARTBEAT)
+ private int requestedHeartbeat = ConnectionFactory.DEFAULT_HEARTBEAT;
+ @Metadata(label = "advanced")
+ private Boolean automaticRecoveryEnabled;
+ @Metadata(label = "advanced", defaultValue = "5000")
+ private Integer networkRecoveryInterval = 5000;
+ @Metadata(label = "advanced")
+ private Boolean topologyRecoveryEnabled;
+ @Metadata(label = "consumer")
+ private boolean prefetchEnabled;
+ @Metadata(label = "consumer")
+ private int prefetchSize;
+ @Metadata(label = "consumer")
+ private int prefetchCount;
+ @Metadata(label = "consumer")
+ private boolean prefetchGlobal;
+ @Metadata(label = "producer", defaultValue = "10")
+ private int channelPoolMaxSize = 10;
+ @Metadata(label = "producer", defaultValue = "1000")
+ private long channelPoolMaxWait = 1000;
+ @Metadata(label = "advanced", defaultValue = "20000")
+ private long requestTimeout = 20000;
+ @Metadata(label = "advanced", defaultValue = "1000")
+ private long requestTimeoutCheckerInterval = 1000;
+ @Metadata(label = "advanced")
+ private boolean transferException;
+ @Metadata(label = "producer")
+ private boolean mandatory;
+ @Metadata(label = "producer")
+ private boolean immediate;
+ @Metadata(label = "producer")
+ private boolean publisherAcknowledgements;
+ @Metadata(label = "producer")
+ private long publisherAcknowledgementsTimeout;
+ @Metadata(label = "producer")
+ private boolean guaranteedDeliveries;
+ @Metadata(label = "advanced")
+ private Map<String, Object> args;
+ @Metadata(label = "advanced")
+ private Map<String, Object> clientProperties;
public RabbitMQComponent() {
super(RabbitMQEndpoint.class);
@@ -104,8 +160,8 @@ public class RabbitMQComponent extends UriEndpointComponent {
}
@SuppressWarnings("unchecked")
- Map<String, Object> clientProperties = resolveAndRemoveReferenceParameter(params, "clientProperties", Map.class);
- TrustManager trustManager = resolveAndRemoveReferenceParameter(params, "trustManager", TrustManager.class);
+ Map<String, Object> clientProperties = resolveAndRemoveReferenceParameter(params, "clientProperties", Map.class, getClientProperties());
+ TrustManager trustManager = resolveAndRemoveReferenceParameter(params, "trustManager", TrustManager.class, getTrustManager());
RabbitMQEndpoint endpoint;
if (connectionFactory == null) {
endpoint = new RabbitMQEndpoint(uri, this);
@@ -116,9 +172,34 @@ public class RabbitMQComponent extends UriEndpointComponent {
endpoint.setPortNumber(port);
endpoint.setUsername(getUsername());
endpoint.setPassword(getPassword());
+ endpoint.setVhost(getVhost());
+ endpoint.setAddresses(getAddresses());
+ endpoint.setThreadPoolSize(getThreadPoolSize());
endpoint.setExchangeName(exchangeName);
endpoint.setClientProperties(clientProperties);
+ endpoint.setSslProtocol(getSslProtocol());
endpoint.setTrustManager(trustManager);
+ endpoint.setConnectionTimeout(getConnectionTimeout());
+ endpoint.setRequestedChannelMax(getRequestedChannelMax());
+ endpoint.setRequestedFrameMax(getRequestedFrameMax());
+ endpoint.setRequestedHeartbeat(getRequestedHeartbeat());
+ endpoint.setAutomaticRecoveryEnabled(getAutomaticRecoveryEnabled());
+ endpoint.setNetworkRecoveryInterval(getNetworkRecoveryInterval());
+ endpoint.setTopologyRecoveryEnabled(getTopologyRecoveryEnabled());
+ endpoint.setPrefetchEnabled(isPrefetchEnabled());
+ endpoint.setPrefetchSize(getPrefetchSize());
+ endpoint.setPrefetchCount(getPrefetchCount());
+ endpoint.setPrefetchGlobal(isPrefetchGlobal());
+ endpoint.setChannelPoolMaxSize(getChannelPoolMaxSize());
+ endpoint.setChannelPoolMaxWait(getChannelPoolMaxWait());
+ endpoint.setRequestTimeout(getRequestTimeout());
+ endpoint.setRequestTimeoutCheckerInterval(getRequestTimeoutCheckerInterval());
+ endpoint.setTransferException(isTransferException());
+ endpoint.setPublisherAcknowledgements(isPublisherAcknowledgements());
+ endpoint.setPublisherAcknowledgementsTimeout(getPublisherAcknowledgementsTimeout());
+ endpoint.setGuaranteedDeliveries(isGuaranteedDeliveries());
+ endpoint.setMandatory(isMandatory());
+ endpoint.setImmediate(isImmediate());
setProperties(endpoint, params);
if (LOG.isDebugEnabled()) {
@@ -126,11 +207,15 @@ public class RabbitMQComponent extends UriEndpointComponent {
new Object[]{endpoint.getHostname(), endpoint.getPortNumber(), endpoint.getExchangeName()});
}
- HashMap<String, Object> args = new HashMap<>();
- args.putAll(IntrospectionSupport.extractProperties(params, ARG_PREFIX));
- endpoint.setArgs(args);
+ Map<String, Object> localArgs = new HashMap<>();
+ if (getArgs() != null) {
+ // copy over the component configured args
+ localArgs.putAll(getArgs());
+ }
+ localArgs.putAll(IntrospectionSupport.extractProperties(params, ARG_PREFIX));
+ endpoint.setArgs(localArgs);
- HashMap<String, Object> argsCopy = new HashMap<>(args);
+ Map<String, Object> argsCopy = new HashMap<>(localArgs);
// Combine the three types of rabbit arguments with their individual endpoint properties
endpoint.getExchangeArgs().putAll(IntrospectionSupport.extractProperties(argsCopy, EXCHANGE_ARG_PREFIX));
@@ -184,6 +269,42 @@ public class RabbitMQComponent extends UriEndpointComponent {
this.password = password;
}
+ public String getVhost() {
+ return vhost;
+ }
+
+ /**
+ * The vhost for the channel
+ */
+ public void setVhost(String vhost) {
+ this.vhost = vhost;
+ }
+
+ /**
+ * If this option is set, camel-rabbitmq will try to create connection based
+ * on the setting of option addresses. The addresses value is a string which
+ * looks like "server1:12345, server2:12345"
+ */
+ public void setAddresses(String addresses) {
+ Address[] addressArray = Address.parseAddresses(addresses);
+ if (addressArray.length > 0) {
+ this.addresses = addressArray;
+ }
+ }
+
+ /**
+ * If this option is set, camel-rabbitmq will try to create connection based
+ * on the setting of option addresses. The addresses value is a string which
+ * looks like "server1:12345, server2:12345"
+ */
+ public void setAddresses(Address[] addresses) {
+ this.addresses = addresses;
+ }
+
+ public Address[] getAddresses() {
+ return addresses;
+ }
+
public ConnectionFactory getConnectionFactory() {
return connectionFactory;
}
@@ -197,6 +318,18 @@ public class RabbitMQComponent extends UriEndpointComponent {
this.connectionFactory = connectionFactory;
}
+ public int getThreadPoolSize() {
+ return threadPoolSize;
+ }
+
+ /**
+ * The consumer uses a Thread Pool Executor with a fixed number of threads.
+ * This setting allows you to set that number of threads.
+ */
+ public void setThreadPoolSize(int threadPoolSize) {
+ this.threadPoolSize = threadPoolSize;
+ }
+
public boolean isAutoDetectConnectionFactory() {
return autoDetectConnectionFactory;
}
@@ -209,4 +342,320 @@ public class RabbitMQComponent extends UriEndpointComponent {
public void setAutoDetectConnectionFactory(boolean autoDetectConnectionFactory) {
this.autoDetectConnectionFactory = autoDetectConnectionFactory;
}
+
+ public int getConnectionTimeout() {
+ return connectionTimeout;
+ }
+
+ /**
+ * Connection timeout
+ */
+ public void setConnectionTimeout(int connectionTimeout) {
+ this.connectionTimeout = connectionTimeout;
+ }
+
+ public int getRequestedChannelMax() {
+ return requestedChannelMax;
+ }
+
+ /**
+ * Connection requested channel max (max number of channels offered)
+ */
+ public void setRequestedChannelMax(int requestedChannelMax) {
+ this.requestedChannelMax = requestedChannelMax;
+ }
+
+ public int getRequestedFrameMax() {
+ return requestedFrameMax;
+ }
+
+ /**
+ * Connection requested frame max (max size of frame offered)
+ */
+ public void setRequestedFrameMax(int requestedFrameMax) {
+ this.requestedFrameMax = requestedFrameMax;
+ }
+
+ public int getRequestedHeartbeat() {
+ return requestedHeartbeat;
+ }
+
+ /**
+ * Connection requested heartbeat (heart-beat in seconds offered)
+ */
+ public void setRequestedHeartbeat(int requestedHeartbeat) {
+ this.requestedHeartbeat = requestedHeartbeat;
+ }
+
+ public Boolean getAutomaticRecoveryEnabled() {
+ return automaticRecoveryEnabled;
+ }
+
+ /**
+ * Enables connection automatic recovery (uses connection implementation
+ * that performs automatic recovery when connection shutdown is not
+ * initiated by the application)
+ */
+ public void setAutomaticRecoveryEnabled(Boolean automaticRecoveryEnabled) {
+ this.automaticRecoveryEnabled = automaticRecoveryEnabled;
+ }
+
+ public Integer getNetworkRecoveryInterval() {
+ return networkRecoveryInterval;
+ }
+
+ /**
+ * Network recovery interval in milliseconds (interval used when recovering
+ * from network failure)
+ */
+ public void setNetworkRecoveryInterval(Integer networkRecoveryInterval) {
+ this.networkRecoveryInterval = networkRecoveryInterval;
+ }
+
+ public Boolean getTopologyRecoveryEnabled() {
+ return topologyRecoveryEnabled;
+ }
+
+ /**
+ * Enables connection topology recovery (should topology recovery be
+ * performed?)
+ */
+ public void setTopologyRecoveryEnabled(Boolean topologyRecoveryEnabled) {
+ this.topologyRecoveryEnabled = topologyRecoveryEnabled;
+ }
+
+ public boolean isPrefetchEnabled() {
+ return prefetchEnabled;
+ }
+
+ /**
+ * Enables the quality of service on the RabbitMQConsumer side. You need to
+ * specify the option of prefetchSize, prefetchCount, prefetchGlobal at the
+ * same time
+ */
+ public void setPrefetchEnabled(boolean prefetchEnabled) {
+ this.prefetchEnabled = prefetchEnabled;
+ }
+
+ /**
+ * The maximum amount of content (measured in octets) that the server will
+ * deliver, 0 if unlimited. You need to specify the option of prefetchSize,
+ * prefetchCount, prefetchGlobal at the same time
+ */
+ public void setPrefetchSize(int prefetchSize) {
+ this.prefetchSize = prefetchSize;
+ }
+
+ public int getPrefetchSize() {
+ return prefetchSize;
+ }
+
+ /**
+ * The maximum number of messages that the server will deliver, 0 if
+ * unlimited. You need to specify the option of prefetchSize, prefetchCount,
+ * prefetchGlobal at the same time
+ */
+ public void setPrefetchCount(int prefetchCount) {
+ this.prefetchCount = prefetchCount;
+ }
+
+ public int getPrefetchCount() {
+ return prefetchCount;
+ }
+
+ /**
+ * If the settings should be applied to the entire channel rather than each
+ * consumer You need to specify the option of prefetchSize, prefetchCount,
+ * prefetchGlobal at the same time
+ */
+ public void setPrefetchGlobal(boolean prefetchGlobal) {
+ this.prefetchGlobal = prefetchGlobal;
+ }
+
+ public boolean isPrefetchGlobal() {
+ return prefetchGlobal;
+ }
+
+ /**
+ * Get maximum number of opened channel in pool
+ */
+ public int getChannelPoolMaxSize() {
+ return channelPoolMaxSize;
+ }
+
+ public void setChannelPoolMaxSize(int channelPoolMaxSize) {
+ this.channelPoolMaxSize = channelPoolMaxSize;
+ }
+
+ public long getChannelPoolMaxWait() {
+ return channelPoolMaxWait;
+ }
+
+ /**
+ * Set the maximum number of milliseconds to wait for a channel from the
+ * pool
+ */
+ public void setChannelPoolMaxWait(long channelPoolMaxWait) {
+ this.channelPoolMaxWait = channelPoolMaxWait;
+ }
+
+ /**
+ * Set timeout for waiting for a reply when using the InOut Exchange Pattern
+ * (in milliseconds)
+ */
+ public void setRequestTimeout(long requestTimeout) {
+ this.requestTimeout = requestTimeout;
+ }
+
+ public long getRequestTimeout() {
+ return requestTimeout;
+ }
+
+ /**
+ * Set requestTimeoutCheckerInterval for inOut exchange
+ */
+ public void setRequestTimeoutCheckerInterval(long requestTimeoutCheckerInterval) {
+ this.requestTimeoutCheckerInterval = requestTimeoutCheckerInterval;
+ }
+
+ public long getRequestTimeoutCheckerInterval() {
+ return requestTimeoutCheckerInterval;
+ }
+
+ /**
+ * When true and an inOut Exchange failed on the consumer side send the
+ * caused Exception back in the response
+ */
+ public void setTransferException(boolean transferException) {
+ this.transferException = transferException;
+ }
+
+ public boolean isTransferException() {
+ return transferException;
+ }
+
+ /**
+ * When true, the message will be published with
+ * <a href="https://www.rabbitmq.com/confirms.html">publisher acknowledgements</a> turned on
+ */
+ public boolean isPublisherAcknowledgements() {
+ return publisherAcknowledgements;
+ }
+
+ public void setPublisherAcknowledgements(final boolean publisherAcknowledgements) {
+ this.publisherAcknowledgements = publisherAcknowledgements;
+ }
+
+ /**
+ * The amount of time in milliseconds to wait for a basic.ack response from
+ * RabbitMQ server
+ */
+ public long getPublisherAcknowledgementsTimeout() {
+ return publisherAcknowledgementsTimeout;
+ }
+
+ public void setPublisherAcknowledgementsTimeout(final long publisherAcknowledgementsTimeout) {
+ this.publisherAcknowledgementsTimeout = publisherAcknowledgementsTimeout;
+ }
+
+ /**
+ * When true, an exception will be thrown when the message cannot be
+ * delivered (basic.return) and the message is marked as mandatory.
+ * PublisherAcknowledgement will also be activated in this case.
+ * See also <a href=https://www.rabbitmq.com/confirms.html">publisher acknowledgements</a>
+ * - When will messages be confirmed.
+ */
+ public boolean isGuaranteedDeliveries() {
+ return guaranteedDeliveries;
+ }
+
+ public void setGuaranteedDeliveries(boolean guaranteedDeliveries) {
+ this.guaranteedDeliveries = guaranteedDeliveries;
+ }
+
+ public boolean isMandatory() {
+ return mandatory;
+ }
+
+ /**
+ * This flag tells the server how to react if the message cannot be routed
+ * to a queue. If this flag is set, the server will return an unroutable
+ * message with a Return method. If this flag is zero, the server silently
+ * drops the message.
+ * <p/>
+ * If the header is present rabbitmq.MANDATORY it will override this option.
+ */
+ public void setMandatory(boolean mandatory) {
+ this.mandatory = mandatory;
+ }
+
+ public boolean isImmediate() {
+ return immediate;
+ }
+
+ /**
+ * This flag tells the server how to react if the message cannot be routed
+ * to a queue consumer immediately. If this flag is set, the server will
+ * return an undeliverable message with a Return method. If this flag is
+ * zero, the server will queue the message, but with no guarantee that it
+ * will ever be consumed.
+ * <p/>
+ * If the header is present rabbitmq.IMMEDIATE it will override this option.
+ */
+ public void setImmediate(boolean immediate) {
+ this.immediate = immediate;
+ }
+
+ /**
+ * Specify arguments for configuring the different RabbitMQ concepts, a
+ * different prefix is required for each:
+ * <ul>
+ * <li>Exchange: arg.exchange.</li>
+ * <li>Queue: arg.queue.</li>
+ * <li>Binding: arg.binding.</li>
+ * </ul>
+ * For example to declare a queue with message ttl argument:
+ * http://localhost:5672/exchange/queue?args=arg.queue.x-message-ttl=60000
+ */
+ public void setArgs(Map<String, Object> args) {
+ this.args = args;
+ }
+
+ public Map<String, Object> getArgs() {
+ return args;
+ }
+
+ public Map<String, Object> getClientProperties() {
+ return clientProperties;
+ }
+
+ /**
+ * Connection client properties (client info used in negotiating with the server)
+ */
+ public void setClientProperties(Map<String, Object> clientProperties) {
+ this.clientProperties = clientProperties;
+ }
+
+ public String getSslProtocol() {
+ return sslProtocol;
+ }
+
+ /**
+ * Enables SSL on connection, accepted value are `true`, `TLS` and 'SSLv3`
+ */
+ public void setSslProtocol(String sslProtocol) {
+ this.sslProtocol = sslProtocol;
+ }
+
+ public TrustManager getTrustManager() {
+ return trustManager;
+ }
+
+ /**
+ * Configure SSL trust manager, SSL should be enabled for this option to be effective
+ */
+ public void setTrustManager(TrustManager trustManager) {
+ this.trustManager = trustManager;
+ }
+
}
diff --git a/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQEndpoint.java b/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQEndpoint.java
index 480fe73..86e60d5 100644
--- a/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQEndpoint.java
+++ b/components/camel-rabbitmq/src/main/java/org/apache/camel/component/rabbitmq/RabbitMQEndpoint.java
@@ -64,7 +64,7 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
private String username = ConnectionFactory.DEFAULT_USER;
@UriParam(label = "security", defaultValue = ConnectionFactory.DEFAULT_PASS, secret = true)
private String password = ConnectionFactory.DEFAULT_PASS;
- @UriParam(defaultValue = ConnectionFactory.DEFAULT_VHOST)
+ @UriParam(label = "common", defaultValue = ConnectionFactory.DEFAULT_VHOST)
private String vhost = ConnectionFactory.DEFAULT_VHOST;
@UriParam(label = "common")
private ConnectionFactory connectionFactory;
@@ -94,9 +94,9 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
private boolean skipQueueBind;
@UriParam(label = "common")
private boolean skipExchangeDeclare;
- @UriParam(label = "advanced")
+ @UriParam(label = "common")
private Address[] addresses;
- @UriParam(defaultValue = "" + ConnectionFactory.DEFAULT_CONNECTION_TIMEOUT)
+ @UriParam(label = "advanced", defaultValue = "" + ConnectionFactory.DEFAULT_CONNECTION_TIMEOUT)
private int connectionTimeout = ConnectionFactory.DEFAULT_CONNECTION_TIMEOUT;
@UriParam(label = "advanced", defaultValue = "" + ConnectionFactory.DEFAULT_CHANNEL_MAX)
private int requestedChannelMax = ConnectionFactory.DEFAULT_CHANNEL_MAX;
@@ -426,8 +426,6 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
/**
* If true the queue will not be bound to the exchange after declaring it
- *
- * @return
*/
public boolean isSkipQueueBind() {
return skipQueueBind;
@@ -472,6 +470,15 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
}
}
+ /**
+ * If this option is set, camel-rabbitmq will try to create connection based
+ * on the setting of option addresses. The addresses value is a string which
+ * looks like "server1:12345, server2:12345"
+ */
+ public void setAddresses(Address[] addresses) {
+ this.addresses = addresses;
+ }
+
public Address[] getAddresses() {
return addresses;
}
@@ -549,8 +556,7 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
}
/**
- * Configure SSL trust manager, SSL should be enabled for this option to be
- * effective
+ * Configure SSL trust manager, SSL should be enabled for this option to be effective
*/
public void setTrustManager(TrustManager trustManager) {
this.trustManager = trustManager;
@@ -561,8 +567,7 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
}
/**
- * Connection client properties (client info used in negotiating with the
- * server)
+ * Connection client properties (client info used in negotiating with the server)
*/
public void setClientProperties(Map<String, Object> clientProperties) {
this.clientProperties = clientProperties;
@@ -917,8 +922,7 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
/**
* When true, the message will be published with
- * <a href="https://www.rabbitmq.com/confirms.html">publisher
- * acknowledgements</a> turned on
+ * <a href="https://www.rabbitmq.com/confirms.html">publisher acknowledgements</a> turned on
*/
public boolean isPublisherAcknowledgements() {
return publisherAcknowledgements;
@@ -943,9 +947,9 @@ public class RabbitMQEndpoint extends DefaultEndpoint implements AsyncEndpoint {
/**
* When true, an exception will be thrown when the message cannot be
* delivered (basic.return) and the message is marked as mandatory.
- * PublisherAcknowledgement will also be activated in this case See also <a
- * href=https://www.rabbitmq.com/confirms.html">publisher
- * acknowledgements</a> - When will messages be confirmed?
+ * PublisherAcknowledgement will also be activated in this case.
+ * See also <a href=https://www.rabbitmq.com/confirms.html">publisher acknowledgements</a>
+ * - When will messages be confirmed.
*/
public boolean isGuaranteedDeliveries() {
return guaranteedDeliveries;
diff --git a/platforms/spring-boot/components-starter/camel-rabbitmq-starter/src/main/java/org/apache/camel/component/rabbitmq/springboot/RabbitMQComponentConfiguration.java b/platforms/spring-boot/components-starter/camel-rabbitmq-starter/src/main/java/org/apache/camel/component/rabbitmq/springboot/RabbitMQComponentConfiguration.java
index 9bee754..69d8032 100644
--- a/platforms/spring-boot/components-starter/camel-rabbitmq-starter/src/main/java/org/apache/camel/component/rabbitmq/springboot/RabbitMQComponentConfiguration.java
+++ b/platforms/spring-boot/components-starter/camel-rabbitmq-starter/src/main/java/org/apache/camel/component/rabbitmq/springboot/RabbitMQComponentConfiguration.java
@@ -16,7 +16,9 @@
*/
package org.apache.camel.component.rabbitmq.springboot;
+import java.util.Map;
import javax.annotation.Generated;
+import javax.net.ssl.TrustManager;
import com.rabbitmq.client.ConnectionFactory;
import org.apache.camel.spring.boot.ComponentConfigurationPropertiesCommon;
import org.springframework.boot.context.properties.ConfigurationProperties;
@@ -51,6 +53,16 @@ public class RabbitMQComponentConfiguration
*/
private String password = "guest";
/**
+ * The vhost for the channel
+ */
+ private String vhost = "/";
+ /**
+ * If this option is set, camel-rabbitmq will try to create connection based
+ * on the setting of option addresses. The addresses value is a string which
+ * looks like server1:12345, server2:12345
+ */
+ private String addresses;
+ /**
* To use a custom RabbitMQ connection factory. When this option is set, all
* connection options (connectionTimeout, requestedChannelMax...) set on URI
* are not used
@@ -58,6 +70,11 @@ public class RabbitMQComponentConfiguration
@NestedConfigurationProperty
private ConnectionFactory connectionFactory;
/**
+ * The consumer uses a Thread Pool Executor with a fixed number of threads.
+ * This setting allows you to set that number of threads.
+ */
+ private Integer threadPoolSize = 10;
+ /**
* Whether to auto-detect looking up RabbitMQ connection factory from the
* registry. When enabled and a single instance of the connection factory is
* found then it will be used. An explicit connection factory can be
@@ -65,6 +82,141 @@ public class RabbitMQComponentConfiguration
*/
private Boolean autoDetectConnectionFactory = true;
/**
+ * Connection timeout
+ */
+ private Integer connectionTimeout = 60000;
+ /**
+ * Connection requested channel max (max number of channels offered)
+ */
+ private Integer requestedChannelMax = 0;
+ /**
+ * Connection requested frame max (max size of frame offered)
+ */
+ private Integer requestedFrameMax = 0;
+ /**
+ * Connection requested heartbeat (heart-beat in seconds offered)
+ */
+ private Integer requestedHeartbeat = 60;
+ /**
+ * Enables connection automatic recovery (uses connection implementation
+ * that performs automatic recovery when connection shutdown is not
+ * initiated by the application)
+ */
+ private Boolean automaticRecoveryEnabled;
+ /**
+ * Network recovery interval in milliseconds (interval used when recovering
+ * from network failure)
+ */
+ private Integer networkRecoveryInterval = 5000;
+ /**
+ * Enables connection topology recovery (should topology recovery be
+ * performed)
+ */
+ private Boolean topologyRecoveryEnabled;
+ /**
+ * Enables the quality of service on the RabbitMQConsumer side. You need to
+ * specify the option of prefetchSize, prefetchCount, prefetchGlobal at the
+ * same time
+ */
+ private Boolean prefetchEnabled = false;
+ /**
+ * The maximum amount of content (measured in octets) that the server will
+ * deliver, 0 if unlimited. You need to specify the option of prefetchSize,
+ * prefetchCount, prefetchGlobal at the same time
+ */
+ private Integer prefetchSize;
+ /**
+ * The maximum number of messages that the server will deliver, 0 if
+ * unlimited. You need to specify the option of prefetchSize, prefetchCount,
+ * prefetchGlobal at the same time
+ */
+ private Integer prefetchCount;
+ /**
+ * If the settings should be applied to the entire channel rather than each
+ * consumer You need to specify the option of prefetchSize, prefetchCount,
+ * prefetchGlobal at the same time
+ */
+ private Boolean prefetchGlobal = false;
+ /**
+ * Get maximum number of opened channel in pool
+ */
+ private Integer channelPoolMaxSize = 10;
+ /**
+ * Set the maximum number of milliseconds to wait for a channel from the
+ * pool
+ */
+ private Long channelPoolMaxWait = 1000L;
+ /**
+ * Set timeout for waiting for a reply when using the InOut Exchange Pattern
+ * (in milliseconds)
+ */
+ private Long requestTimeout = 20000L;
+ /**
+ * Set requestTimeoutCheckerInterval for inOut exchange
+ */
+ private Long requestTimeoutCheckerInterval = 1000L;
+ /**
+ * When true and an inOut Exchange failed on the consumer side send the
+ * caused Exception back in the response
+ */
+ private Boolean transferException = false;
+ /**
+ * When true, the message will be published with publisher acknowledgements
+ * turned on
+ */
+ private Boolean publisherAcknowledgements = false;
+ /**
+ * The amount of time in milliseconds to wait for a basic.ack response from
+ * RabbitMQ server
+ */
+ private Long publisherAcknowledgementsTimeout;
+ /**
+ * When true, an exception will be thrown when the message cannot be
+ * delivered (basic.return) and the message is marked as mandatory.
+ * PublisherAcknowledgement will also be activated in this case. See also
+ * publisher acknowledgements - When will messages be confirmed.
+ */
+ private Boolean guaranteedDeliveries = false;
+ /**
+ * This flag tells the server how to react if the message cannot be routed
+ * to a queue. If this flag is set, the server will return an unroutable
+ * message with a Return method. If this flag is zero, the server silently
+ * drops the message. If the header is present rabbitmq.MANDATORY it will
+ * override this option.
+ */
+ private Boolean mandatory = false;
+ /**
+ * This flag tells the server how to react if the message cannot be routed
+ * to a queue consumer immediately. If this flag is set, the server will
+ * return an undeliverable message with a Return method. If this flag is
+ * zero, the server will queue the message, but with no guarantee that it
+ * will ever be consumed. If the header is present rabbitmq.IMMEDIATE it
+ * will override this option.
+ */
+ private Boolean immediate = false;
+ /**
+ * Specify arguments for configuring the different RabbitMQ concepts, a
+ * different prefix is required for each: Exchange: arg.exchange. Queue:
+ * arg.queue. Binding: arg.binding. For example to declare a queue with
+ * message ttl argument:
+ * http://localhost:5672/exchange/queueargs=arg.queue.x-message-ttl=60000
+ */
+ private Map<String, Object> args;
+ /**
+ * Connection client properties (client info used in negotiating with the
+ * server)
+ */
+ private Map<String, Object> clientProperties;
+ /**
+ * Enables SSL on connection, accepted value are true, TLS and 'SSLv3
+ */
+ private String sslProtocol;
+ /**
+ * Configure SSL trust manager, SSL should be enabled for this option to be
+ * effective
+ */
+ private TrustManager trustManager;
+ /**
* Whether the component should resolve property placeholders on itself when
* starting. Only properties which are of String type can use property
* placeholders.
@@ -103,6 +255,22 @@ public class RabbitMQComponentConfiguration
this.password = password;
}
+ public String getVhost() {
+ return vhost;
+ }
+
+ public void setVhost(String vhost) {
+ this.vhost = vhost;
+ }
+
+ public String getAddresses() {
+ return addresses;
+ }
+
+ public void setAddresses(String addresses) {
+ this.addresses = addresses;
+ }
+
public ConnectionFactory getConnectionFactory() {
return connectionFactory;
}
@@ -111,6 +279,14 @@ public class RabbitMQComponentConfiguration
this.connectionFactory = connectionFactory;
}
+ public Integer getThreadPoolSize() {
+ return threadPoolSize;
+ }
+
+ public void setThreadPoolSize(Integer threadPoolSize) {
+ this.threadPoolSize = threadPoolSize;
+ }
+
public Boolean getAutoDetectConnectionFactory() {
return autoDetectConnectionFactory;
}
@@ -120,6 +296,208 @@ public class RabbitMQComponentConfiguration
this.autoDetectConnectionFactory = autoDetectConnectionFactory;
}
+ public Integer getConnectionTimeout() {
+ return connectionTimeout;
+ }
+
+ public void setConnectionTimeout(Integer connectionTimeout) {
+ this.connectionTimeout = connectionTimeout;
+ }
+
+ public Integer getRequestedChannelMax() {
+ return requestedChannelMax;
+ }
+
+ public void setRequestedChannelMax(Integer requestedChannelMax) {
+ this.requestedChannelMax = requestedChannelMax;
+ }
+
+ public Integer getRequestedFrameMax() {
+ return requestedFrameMax;
+ }
+
+ public void setRequestedFrameMax(Integer requestedFrameMax) {
+ this.requestedFrameMax = requestedFrameMax;
+ }
+
+ public Integer getRequestedHeartbeat() {
+ return requestedHeartbeat;
+ }
+
+ public void setRequestedHeartbeat(Integer requestedHeartbeat) {
+ this.requestedHeartbeat = requestedHeartbeat;
+ }
+
+ public Boolean getAutomaticRecoveryEnabled() {
+ return automaticRecoveryEnabled;
+ }
+
+ public void setAutomaticRecoveryEnabled(Boolean automaticRecoveryEnabled) {
+ this.automaticRecoveryEnabled = automaticRecoveryEnabled;
+ }
+
+ public Integer getNetworkRecoveryInterval() {
+ return networkRecoveryInterval;
+ }
+
+ public void setNetworkRecoveryInterval(Integer networkRecoveryInterval) {
+ this.networkRecoveryInterval = networkRecoveryInterval;
+ }
+
+ public Boolean getTopologyRecoveryEnabled() {
+ return topologyRecoveryEnabled;
+ }
+
+ public void setTopologyRecoveryEnabled(Boolean topologyRecoveryEnabled) {
+ this.topologyRecoveryEnabled = topologyRecoveryEnabled;
+ }
+
+ public Boolean getPrefetchEnabled() {
+ return prefetchEnabled;
+ }
+
+ public void setPrefetchEnabled(Boolean prefetchEnabled) {
+ this.prefetchEnabled = prefetchEnabled;
+ }
+
+ public Integer getPrefetchSize() {
+ return prefetchSize;
+ }
+
+ public void setPrefetchSize(Integer prefetchSize) {
+ this.prefetchSize = prefetchSize;
+ }
+
+ public Integer getPrefetchCount() {
+ return prefetchCount;
+ }
+
+ public void setPrefetchCount(Integer prefetchCount) {
+ this.prefetchCount = prefetchCount;
+ }
+
+ public Boolean getPrefetchGlobal() {
+ return prefetchGlobal;
+ }
+
+ public void setPrefetchGlobal(Boolean prefetchGlobal) {
+ this.prefetchGlobal = prefetchGlobal;
+ }
+
+ public Integer getChannelPoolMaxSize() {
+ return channelPoolMaxSize;
+ }
+
+ public void setChannelPoolMaxSize(Integer channelPoolMaxSize) {
+ this.channelPoolMaxSize = channelPoolMaxSize;
+ }
+
+ public Long getChannelPoolMaxWait() {
+ return channelPoolMaxWait;
+ }
+
+ public void setChannelPoolMaxWait(Long channelPoolMaxWait) {
+ this.channelPoolMaxWait = channelPoolMaxWait;
+ }
+
+ public Long getRequestTimeout() {
+ return requestTimeout;
+ }
+
+ public void setRequestTimeout(Long requestTimeout) {
+ this.requestTimeout = requestTimeout;
+ }
+
+ public Long getRequestTimeoutCheckerInterval() {
+ return requestTimeoutCheckerInterval;
+ }
+
+ public void setRequestTimeoutCheckerInterval(
+ Long requestTimeoutCheckerInterval) {
+ this.requestTimeoutCheckerInterval = requestTimeoutCheckerInterval;
+ }
+
+ public Boolean getTransferException() {
+ return transferException;
+ }
+
+ public void setTransferException(Boolean transferException) {
+ this.transferException = transferException;
+ }
+
+ public Boolean getPublisherAcknowledgements() {
+ return publisherAcknowledgements;
+ }
+
+ public void setPublisherAcknowledgements(Boolean publisherAcknowledgements) {
+ this.publisherAcknowledgements = publisherAcknowledgements;
+ }
+
+ public Long getPublisherAcknowledgementsTimeout() {
+ return publisherAcknowledgementsTimeout;
+ }
+
+ public void setPublisherAcknowledgementsTimeout(
+ Long publisherAcknowledgementsTimeout) {
+ this.publisherAcknowledgementsTimeout = publisherAcknowledgementsTimeout;
+ }
+
+ public Boolean getGuaranteedDeliveries() {
+ return guaranteedDeliveries;
+ }
+
+ public void setGuaranteedDeliveries(Boolean guaranteedDeliveries) {
+ this.guaranteedDeliveries = guaranteedDeliveries;
+ }
+
+ public Boolean getMandatory() {
+ return mandatory;
+ }
+
+ public void setMandatory(Boolean mandatory) {
+ this.mandatory = mandatory;
+ }
+
+ public Boolean getImmediate() {
+ return immediate;
+ }
+
+ public void setImmediate(Boolean immediate) {
+ this.immediate = immediate;
+ }
+
+ public Map<String, Object> getArgs() {
+ return args;
+ }
+
+ public void setArgs(Map<String, Object> args) {
+ this.args = args;
+ }
+
+ public Map<String, Object> getClientProperties() {
+ return clientProperties;
+ }
+
+ public void setClientProperties(Map<String, Object> clientProperties) {
+ this.clientProperties = clientProperties;
+ }
+
+ public String getSslProtocol() {
+ return sslProtocol;
+ }
+
+ public void setSslProtocol(String sslProtocol) {
+ this.sslProtocol = sslProtocol;
+ }
+
+ public TrustManager getTrustManager() {
+ return trustManager;
+ }
+
+ public void setTrustManager(TrustManager trustManager) {
+ this.trustManager = trustManager;
+ }
+
public Boolean getResolvePropertyPlaceholders() {
return resolvePropertyPlaceholders;
}
--
To stop receiving notification emails like this one, please contact
davsclaus@apache.org.