diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/spring-rabbitmq.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/spring-rabbitmq.json index a7f5c0728a12a..601f5d135c574 100644 --- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/spring-rabbitmq.json +++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/spring-rabbitmq.json @@ -26,7 +26,7 @@ "amqpAdmin": { "index": 0, "kind": "property", "displayName": "Amqp Admin", "group": "common", "label": "", "required": false, "type": "object", "javaType": "org.springframework.amqp.core.AmqpAdmin", "deprecated": false, "autowired": true, "secret": false, "description": "Optional AMQP Admin service to use for auto declaring elements (queues, exchanges, bindings)" }, "connectionFactory": { "index": 1, "kind": "property", "displayName": "Connection Factory", "group": "common", "label": "", "required": false, "type": "object", "javaType": "org.springframework.amqp.rabbit.connection.ConnectionFactory", "deprecated": false, "autowired": true, "secret": false, "description": "The connection factory to be use. A connection factory must be configured either on the component or endpoint." }, "testConnectionOnStartup": { "index": 2, "kind": "property", "displayName": "Test Connection On Startup", "group": "common", "label": "", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well." }, - "autoDeclare": { "index": 3, "kind": "property", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting. Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker." }, + "autoDeclare": { "index": 3, "kind": "property", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting. Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker." }, "autoStartup": { "index": 4, "kind": "property", "displayName": "Auto Startup", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer container should auto-startup." }, "bridgeErrorHandler": { "index": 5, "kind": "property", "displayName": "Bridge Error Handler", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored." }, "deadLetterExchange": { "index": 6, "kind": "property", "displayName": "Dead Letter Exchange", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter exchange" }, @@ -45,14 +45,15 @@ "retry": { "index": 19, "kind": "property", "displayName": "Retry", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.springframework.retry.interceptor.RetryOperationsInterceptor", "deprecated": false, "autowired": false, "secret": false, "description": "Custom retry configuration to use. If this is configured then the other settings such as maximumRetryAttempts for retry are not in use." }, "shutdownTimeout": { "index": 20, "kind": "property", "displayName": "Shutdown Timeout", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "The time to wait for workers in milliseconds after the container is stopped. If any workers are active when the shutdown signal comes they will be allowed to finish processing as long as they can finish within this timeout." }, "allowNullBody": { "index": 21, "kind": "property", "displayName": "Allow Null Body", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether to allow sending messages with no body. If this option is false and the message body is null, then an MessageConversionException is thrown." }, - "lazyStartProducer": { "index": 22, "kind": "property", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, - "replyTimeout": { "index": 23, "kind": "property", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply messaging. The default value is 5 seconds. A negative value indicates an indefinite timeout." }, - "args": { "index": 24, "kind": "property", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: consumer. exchange. queue. binding. dlq.exchange. dlq.queue. dlq.binding. For example to declare a queue with message ttl argument: queue.x-message-ttl=60000" }, - "autowiredEnabled": { "index": 25, "kind": "property", "displayName": "Autowired Enabled", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc." }, - "ignoreDeclarationExceptions": { "index": 26, "kind": "property", "displayName": "Ignore Declaration Exceptions", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Switch on ignore exceptions such as mismatched properties when declaring" }, - "messageConverter": { "index": 27, "kind": "property", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, - "messagePropertiesConverter": { "index": 28, "kind": "property", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, - "headerFilterStrategy": { "index": 29, "kind": "property", "displayName": "Header Filter Strategy", "group": "filter", "label": "filter", "required": false, "type": "object", "javaType": "org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message." } + "autoDeclareProducer": { "index": 22, "kind": "property", "displayName": "Auto Declare Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether the producer should auto declare binding between exchange, queue and routing key when starting. Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker." }, + "lazyStartProducer": { "index": 23, "kind": "property", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, + "replyTimeout": { "index": 24, "kind": "property", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply messaging. The default value is 5 seconds. A negative value indicates an indefinite timeout." }, + "args": { "index": 25, "kind": "property", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: consumer. exchange. queue. binding. dlq.exchange. dlq.queue. dlq.binding. For example to declare a queue with message ttl argument: queue.x-message-ttl=60000" }, + "autowiredEnabled": { "index": 26, "kind": "property", "displayName": "Autowired Enabled", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc." }, + "ignoreDeclarationExceptions": { "index": 27, "kind": "property", "displayName": "Ignore Declaration Exceptions", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Switch on ignore exceptions such as mismatched properties when declaring" }, + "messageConverter": { "index": 28, "kind": "property", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, + "messagePropertiesConverter": { "index": 29, "kind": "property", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, + "headerFilterStrategy": { "index": 30, "kind": "property", "displayName": "Header Filter Strategy", "group": "filter", "label": "filter", "required": false, "type": "object", "javaType": "org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message." } }, "headers": { "CamelSpringRabbitmqRoutingOverrideKey": { "index": 0, "kind": "header", "displayName": "", "group": "producer", "label": "producer", "required": false, "javaType": "String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "To override the endpoint configuration's routing key.", "constantName": "org.apache.camel.component.springrabbit.SpringRabbitMQConstants#ROUTING_OVERRIDE_KEY" }, @@ -79,22 +80,22 @@ "properties": { "exchangeName": { "index": 0, "kind": "path", "displayName": "Exchange Name", "group": "common", "label": "", "required": true, "type": "string", "javaType": "java.lang.String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "The exchange name determines the exchange to which the produced messages will be sent to. In the case of consumers, the exchange name determines the exchange the queue will be bound to. Note: to use default exchange then do not use empty name, but use default instead." }, "connectionFactory": { "index": 1, "kind": "parameter", "displayName": "Connection Factory", "group": "common", "label": "common", "required": false, "type": "object", "javaType": "org.springframework.amqp.rabbit.connection.ConnectionFactory", "deprecated": false, "autowired": false, "secret": false, "description": "The connection factory to be use. A connection factory must be configured either on the component or endpoint." }, - "disableReplyTo": { "index": 2, "kind": "parameter", "displayName": "Disable Reply To", "group": "common", "label": "common", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether Camel ignores the ReplyTo header in messages. If true, Camel does not send a reply back to the destination specified in the ReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message brokers and you want to route message from one system to another." }, - "routingKey": { "index": 3, "kind": "parameter", "displayName": "Routing Key", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The value of a routing key to use. Default is empty which is not helpful when using the default (or any direct) exchange, but fine if the exchange is a headers exchange for instance." }, - "testConnectionOnStartup": { "index": 4, "kind": "parameter", "displayName": "Test Connection On Startup", "group": "common", "label": "", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well." }, - "acknowledgeMode": { "index": 5, "kind": "parameter", "displayName": "Acknowledge Mode", "group": "consumer", "label": "consumer", "required": false, "type": "object", "javaType": "org.springframework.amqp.core.AcknowledgeMode", "enum": [ "NONE", "MANUAL", "AUTO" ], "deprecated": false, "autowired": false, "secret": false, "description": "Flag controlling the behaviour of the container with respect to message acknowledgement. The most common usage is to let the container handle the acknowledgements (so the listener doesn't need to know about the channel or the message). Set to AcknowledgeMode.MANUAL if the listener will send the acknowledgements itself using Channel.basicAck(long, boolean). Manual acks are consistent with either a transactional or non-transactional channel, but if you are doing no other work on the channel at the same other than receiving a single message then the transaction is probably unnecessary. Set to AcknowledgeMode.NONE to tell the broker not to expect any acknowledgements, and it will assume all messages are acknowledged as soon as they are sent (this is autoack in native Rabbit broker terms). If AcknowledgeMode.NONE then the channel cannot be transactional (so the container will fail on start up if that flag is accidentally set)." }, - "asyncConsumer": { "index": 6, "kind": "parameter", "displayName": "Async Consumer", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the consumer processes the Exchange asynchronously. If enabled then the consumer may pickup the next message from the queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100% strictly in order. If disabled (as default) then the Exchange is fully processed before the consumer will pickup the next message from the queue." }, - "autoDeclare": { "index": 7, "kind": "parameter", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting." }, - "autoStartup": { "index": 8, "kind": "parameter", "displayName": "Auto Startup", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer container should auto-startup." }, - "deadLetterExchange": { "index": 9, "kind": "parameter", "displayName": "Dead Letter Exchange", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter exchange" }, - "deadLetterExchangeType": { "index": 10, "kind": "parameter", "displayName": "Dead Letter Exchange Type", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the dead letter exchange" }, - "deadLetterQueue": { "index": 11, "kind": "parameter", "displayName": "Dead Letter Queue", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter queue" }, - "deadLetterRoutingKey": { "index": 12, "kind": "parameter", "displayName": "Dead Letter Routing Key", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The routing key for the dead letter exchange" }, - "exchangeType": { "index": 13, "kind": "parameter", "displayName": "Exchange Type", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the exchange" }, - "exclusive": { "index": 14, "kind": "parameter", "displayName": "Exclusive", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an exclusive consumer" }, - "maximumRetryAttempts": { "index": 15, "kind": "parameter", "displayName": "Maximum Retry Attempts", "group": "consumer", "label": "consumer", "required": false, "type": "integer", "javaType": "int", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 5, "description": "How many times a Rabbitmq consumer will retry the same message if Camel failed to process the message" }, - "noLocal": { "index": 16, "kind": "parameter", "displayName": "No Local", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an no-local consumer" }, - "queues": { "index": 17, "kind": "parameter", "displayName": "Queues", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The queue(s) to use for consuming messages. Multiple queue names can be separated by comma. If none has been configured then Camel will generate an unique id as the queue name for the consumer." }, + "deadLetterExchange": { "index": 2, "kind": "parameter", "displayName": "Dead Letter Exchange", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter exchange" }, + "deadLetterExchangeType": { "index": 3, "kind": "parameter", "displayName": "Dead Letter Exchange Type", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the dead letter exchange" }, + "deadLetterQueue": { "index": 4, "kind": "parameter", "displayName": "Dead Letter Queue", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter queue" }, + "deadLetterRoutingKey": { "index": 5, "kind": "parameter", "displayName": "Dead Letter Routing Key", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The routing key for the dead letter exchange" }, + "disableReplyTo": { "index": 6, "kind": "parameter", "displayName": "Disable Reply To", "group": "common", "label": "common", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether Camel ignores the ReplyTo header in messages. If true, Camel does not send a reply back to the destination specified in the ReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message brokers and you want to route message from one system to another." }, + "queues": { "index": 7, "kind": "parameter", "displayName": "Queues", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The queue(s) to use for consuming or producing messages. Multiple queue names can be separated by comma. If none has been configured then Camel will generate an unique id as the queue name." }, + "routingKey": { "index": 8, "kind": "parameter", "displayName": "Routing Key", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The value of a routing key to use. Default is empty which is not helpful when using the default (or any direct) exchange, but fine if the exchange is a headers exchange for instance." }, + "testConnectionOnStartup": { "index": 9, "kind": "parameter", "displayName": "Test Connection On Startup", "group": "common", "label": "", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well." }, + "acknowledgeMode": { "index": 10, "kind": "parameter", "displayName": "Acknowledge Mode", "group": "consumer", "label": "consumer", "required": false, "type": "object", "javaType": "org.springframework.amqp.core.AcknowledgeMode", "enum": [ "NONE", "MANUAL", "AUTO" ], "deprecated": false, "autowired": false, "secret": false, "description": "Flag controlling the behaviour of the container with respect to message acknowledgement. The most common usage is to let the container handle the acknowledgements (so the listener doesn't need to know about the channel or the message). Set to AcknowledgeMode.MANUAL if the listener will send the acknowledgements itself using Channel.basicAck(long, boolean). Manual acks are consistent with either a transactional or non-transactional channel, but if you are doing no other work on the channel at the same other than receiving a single message then the transaction is probably unnecessary. Set to AcknowledgeMode.NONE to tell the broker not to expect any acknowledgements, and it will assume all messages are acknowledged as soon as they are sent (this is autoack in native Rabbit broker terms). If AcknowledgeMode.NONE then the channel cannot be transactional (so the container will fail on start up if that flag is accidentally set)." }, + "asyncConsumer": { "index": 11, "kind": "parameter", "displayName": "Async Consumer", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the consumer processes the Exchange asynchronously. If enabled then the consumer may pickup the next message from the queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100% strictly in order. If disabled (as default) then the Exchange is fully processed before the consumer will pickup the next message from the queue." }, + "autoDeclare": { "index": 12, "kind": "parameter", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting." }, + "autoStartup": { "index": 13, "kind": "parameter", "displayName": "Auto Startup", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer container should auto-startup." }, + "exchangeType": { "index": 14, "kind": "parameter", "displayName": "Exchange Type", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the exchange" }, + "exclusive": { "index": 15, "kind": "parameter", "displayName": "Exclusive", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an exclusive consumer" }, + "maximumRetryAttempts": { "index": 16, "kind": "parameter", "displayName": "Maximum Retry Attempts", "group": "consumer", "label": "consumer", "required": false, "type": "integer", "javaType": "int", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 5, "description": "How many times a Rabbitmq consumer will retry the same message if Camel failed to process the message" }, + "noLocal": { "index": 17, "kind": "parameter", "displayName": "No Local", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an no-local consumer" }, "rejectAndDontRequeue": { "index": 18, "kind": "parameter", "displayName": "Reject And Dont Requeue", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether a Rabbitmq consumer should reject the message without requeuing. This enables failed messages to be sent to a Dead Letter Exchange\/Queue, if the broker is so configured." }, "retryDelay": { "index": 19, "kind": "parameter", "displayName": "Retry Delay", "group": "consumer", "label": "consumer", "required": false, "type": "integer", "javaType": "int", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 1000, "description": "Delay in millis a Rabbitmq consumer will wait before redelivering a message that Camel failed to process" }, "bridgeErrorHandler": { "index": 20, "kind": "parameter", "displayName": "Bridge Error Handler", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored." }, @@ -106,14 +107,15 @@ "prefetchCount": { "index": 26, "kind": "parameter", "displayName": "Prefetch Count", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "integer", "javaType": "java.lang.Integer", "deprecated": false, "autowired": false, "secret": false, "description": "Tell the broker how many messages to send in a single request. Often this can be set quite high to improve throughput." }, "retry": { "index": 27, "kind": "parameter", "displayName": "Retry", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.springframework.retry.interceptor.RetryOperationsInterceptor", "deprecated": false, "autowired": false, "secret": false, "description": "Custom retry configuration to use. If this is configured then the other settings such as maximumRetryAttempts for retry are not in use." }, "allowNullBody": { "index": 28, "kind": "parameter", "displayName": "Allow Null Body", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether to allow sending messages with no body. If this option is false and the message body is null, then an MessageConversionException is thrown." }, - "confirm": { "index": 29, "kind": "parameter", "displayName": "Confirm", "group": "producer", "label": "producer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "auto", "enabled", "disabled" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "auto", "description": "Controls whether to wait for confirms. The connection factory must be configured for publisher confirms and this method. auto = Camel detects if the connection factory uses confirms or not. disabled = Confirms is disabled. enabled = Confirms is enabled." }, - "confirmTimeout": { "index": 30, "kind": "parameter", "displayName": "Confirm Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a message sent to be confirmed by RabbitMQ when doing send only messaging (InOnly). The default value is 5 seconds. A negative value indicates an indefinite timeout." }, - "replyTimeout": { "index": 31, "kind": "parameter", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "30000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply (InOut) messaging. The default value is 30 seconds. A negative value indicates an indefinite timeout (Beware that this will cause a memory leak if a reply is not received)." }, - "usePublisherConnection": { "index": 32, "kind": "parameter", "displayName": "Use Publisher Connection", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Use a separate connection for publishers and consumers" }, - "lazyStartProducer": { "index": 33, "kind": "parameter", "displayName": "Lazy Start Producer", "group": "producer (advanced)", "label": "producer,advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, - "args": { "index": 34, "kind": "parameter", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "prefix": "arg.", "multiValue": true, "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: arg.consumer. arg.exchange. arg.queue. arg.binding. arg.dlq.exchange. arg.dlq.queue. arg.dlq.binding. For example to declare a queue with message ttl argument: args=arg.queue.x-message-ttl=60000" }, - "messageConverter": { "index": 35, "kind": "parameter", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, - "messagePropertiesConverter": { "index": 36, "kind": "parameter", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, - "synchronous": { "index": 37, "kind": "parameter", "displayName": "Synchronous", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Sets whether synchronous processing should be strictly used" } + "autoDeclareProducer": { "index": 29, "kind": "parameter", "displayName": "Auto Declare Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether the producer should auto declare binding between exchange, queue and routing key when starting." }, + "confirm": { "index": 30, "kind": "parameter", "displayName": "Confirm", "group": "producer", "label": "producer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "auto", "enabled", "disabled" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "auto", "description": "Controls whether to wait for confirms. The connection factory must be configured for publisher confirms and this method. auto = Camel detects if the connection factory uses confirms or not. disabled = Confirms is disabled. enabled = Confirms is enabled." }, + "confirmTimeout": { "index": 31, "kind": "parameter", "displayName": "Confirm Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a message sent to be confirmed by RabbitMQ when doing send only messaging (InOnly). The default value is 5 seconds. A negative value indicates an indefinite timeout." }, + "replyTimeout": { "index": 32, "kind": "parameter", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "30000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply (InOut) messaging. The default value is 30 seconds. A negative value indicates an indefinite timeout (Beware that this will cause a memory leak if a reply is not received)." }, + "usePublisherConnection": { "index": 33, "kind": "parameter", "displayName": "Use Publisher Connection", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Use a separate connection for publishers and consumers" }, + "lazyStartProducer": { "index": 34, "kind": "parameter", "displayName": "Lazy Start Producer", "group": "producer (advanced)", "label": "producer,advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, + "args": { "index": 35, "kind": "parameter", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "prefix": "arg.", "multiValue": true, "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: arg.consumer. arg.exchange. arg.queue. arg.binding. arg.dlq.exchange. arg.dlq.queue. arg.dlq.binding. For example to declare a queue with message ttl argument: args=arg.queue.x-message-ttl=60000" }, + "messageConverter": { "index": 36, "kind": "parameter", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, + "messagePropertiesConverter": { "index": 37, "kind": "parameter", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, + "synchronous": { "index": 38, "kind": "parameter", "displayName": "Synchronous", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Sets whether synchronous processing should be strictly used" } } } diff --git a/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponentConfigurer.java b/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponentConfigurer.java index d9923ad4f5e06..6a603811196ad 100644 --- a/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponentConfigurer.java +++ b/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponentConfigurer.java @@ -28,6 +28,8 @@ public boolean configure(CamelContext camelContext, Object obj, String name, Obj case "args": target.setArgs(property(camelContext, java.util.Map.class, value)); return true; case "autodeclare": case "autoDeclare": target.setAutoDeclare(property(camelContext, boolean.class, value)); return true; + case "autodeclareproducer": + case "autoDeclareProducer": target.setAutoDeclareProducer(property(camelContext, boolean.class, value)); return true; case "autostartup": case "autoStartup": target.setAutoStartup(property(camelContext, boolean.class, value)); return true; case "autowiredenabled": @@ -98,6 +100,8 @@ public Class getOptionType(String name, boolean ignoreCase) { case "args": return java.util.Map.class; case "autodeclare": case "autoDeclare": return boolean.class; + case "autodeclareproducer": + case "autoDeclareProducer": return boolean.class; case "autostartup": case "autoStartup": return boolean.class; case "autowiredenabled": @@ -164,6 +168,8 @@ public Object getOptionValue(Object obj, String name, boolean ignoreCase) { case "args": return target.getArgs(); case "autodeclare": case "autoDeclare": return target.isAutoDeclare(); + case "autodeclareproducer": + case "autoDeclareProducer": return target.isAutoDeclareProducer(); case "autostartup": case "autoStartup": return target.isAutoStartup(); case "autowiredenabled": diff --git a/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointConfigurer.java b/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointConfigurer.java index f11d960a2d505..d65a02dd62de3 100644 --- a/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointConfigurer.java +++ b/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointConfigurer.java @@ -30,6 +30,8 @@ public boolean configure(CamelContext camelContext, Object obj, String name, Obj case "asyncConsumer": target.setAsyncConsumer(property(camelContext, boolean.class, value)); return true; case "autodeclare": case "autoDeclare": target.setAutoDeclare(property(camelContext, boolean.class, value)); return true; + case "autodeclareproducer": + case "autoDeclareProducer": target.setAutoDeclareProducer(property(camelContext, boolean.class, value)); return true; case "autostartup": case "autoStartup": target.setAutoStartup(property(camelContext, boolean.class, value)); return true; case "bridgeerrorhandler": @@ -105,6 +107,8 @@ public Class getOptionType(String name, boolean ignoreCase) { case "asyncConsumer": return boolean.class; case "autodeclare": case "autoDeclare": return boolean.class; + case "autodeclareproducer": + case "autoDeclareProducer": return boolean.class; case "autostartup": case "autoStartup": return boolean.class; case "bridgeerrorhandler": @@ -181,6 +185,8 @@ public Object getOptionValue(Object obj, String name, boolean ignoreCase) { case "asyncConsumer": return target.isAsyncConsumer(); case "autodeclare": case "autoDeclare": return target.isAutoDeclare(); + case "autodeclareproducer": + case "autoDeclareProducer": return target.isAutoDeclareProducer(); case "autostartup": case "autoStartup": return target.isAutoStartup(); case "bridgeerrorhandler": diff --git a/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointUriFactory.java b/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointUriFactory.java index 9e0bc71025f59..c3a5151cadac8 100644 --- a/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointUriFactory.java +++ b/components/camel-spring-rabbitmq/src/generated/java/org/apache/camel/component/springrabbit/SpringRabbitMQEndpointUriFactory.java @@ -21,12 +21,13 @@ public class SpringRabbitMQEndpointUriFactory extends org.apache.camel.support.c private static final Set SECRET_PROPERTY_NAMES; private static final Set MULTI_VALUE_PREFIXES; static { - Set props = new HashSet<>(38); + Set props = new HashSet<>(39); props.add("acknowledgeMode"); props.add("allowNullBody"); props.add("args"); props.add("asyncConsumer"); props.add("autoDeclare"); + props.add("autoDeclareProducer"); props.add("autoStartup"); props.add("bridgeErrorHandler"); props.add("concurrentConsumers"); diff --git a/components/camel-spring-rabbitmq/src/generated/resources/META-INF/org/apache/camel/component/springrabbit/spring-rabbitmq.json b/components/camel-spring-rabbitmq/src/generated/resources/META-INF/org/apache/camel/component/springrabbit/spring-rabbitmq.json index a7f5c0728a12a..601f5d135c574 100644 --- a/components/camel-spring-rabbitmq/src/generated/resources/META-INF/org/apache/camel/component/springrabbit/spring-rabbitmq.json +++ b/components/camel-spring-rabbitmq/src/generated/resources/META-INF/org/apache/camel/component/springrabbit/spring-rabbitmq.json @@ -26,7 +26,7 @@ "amqpAdmin": { "index": 0, "kind": "property", "displayName": "Amqp Admin", "group": "common", "label": "", "required": false, "type": "object", "javaType": "org.springframework.amqp.core.AmqpAdmin", "deprecated": false, "autowired": true, "secret": false, "description": "Optional AMQP Admin service to use for auto declaring elements (queues, exchanges, bindings)" }, "connectionFactory": { "index": 1, "kind": "property", "displayName": "Connection Factory", "group": "common", "label": "", "required": false, "type": "object", "javaType": "org.springframework.amqp.rabbit.connection.ConnectionFactory", "deprecated": false, "autowired": true, "secret": false, "description": "The connection factory to be use. A connection factory must be configured either on the component or endpoint." }, "testConnectionOnStartup": { "index": 2, "kind": "property", "displayName": "Test Connection On Startup", "group": "common", "label": "", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well." }, - "autoDeclare": { "index": 3, "kind": "property", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting. Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker." }, + "autoDeclare": { "index": 3, "kind": "property", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting. Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker." }, "autoStartup": { "index": 4, "kind": "property", "displayName": "Auto Startup", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer container should auto-startup." }, "bridgeErrorHandler": { "index": 5, "kind": "property", "displayName": "Bridge Error Handler", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored." }, "deadLetterExchange": { "index": 6, "kind": "property", "displayName": "Dead Letter Exchange", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter exchange" }, @@ -45,14 +45,15 @@ "retry": { "index": 19, "kind": "property", "displayName": "Retry", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.springframework.retry.interceptor.RetryOperationsInterceptor", "deprecated": false, "autowired": false, "secret": false, "description": "Custom retry configuration to use. If this is configured then the other settings such as maximumRetryAttempts for retry are not in use." }, "shutdownTimeout": { "index": 20, "kind": "property", "displayName": "Shutdown Timeout", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "The time to wait for workers in milliseconds after the container is stopped. If any workers are active when the shutdown signal comes they will be allowed to finish processing as long as they can finish within this timeout." }, "allowNullBody": { "index": 21, "kind": "property", "displayName": "Allow Null Body", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether to allow sending messages with no body. If this option is false and the message body is null, then an MessageConversionException is thrown." }, - "lazyStartProducer": { "index": 22, "kind": "property", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, - "replyTimeout": { "index": 23, "kind": "property", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply messaging. The default value is 5 seconds. A negative value indicates an indefinite timeout." }, - "args": { "index": 24, "kind": "property", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: consumer. exchange. queue. binding. dlq.exchange. dlq.queue. dlq.binding. For example to declare a queue with message ttl argument: queue.x-message-ttl=60000" }, - "autowiredEnabled": { "index": 25, "kind": "property", "displayName": "Autowired Enabled", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc." }, - "ignoreDeclarationExceptions": { "index": 26, "kind": "property", "displayName": "Ignore Declaration Exceptions", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Switch on ignore exceptions such as mismatched properties when declaring" }, - "messageConverter": { "index": 27, "kind": "property", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, - "messagePropertiesConverter": { "index": 28, "kind": "property", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, - "headerFilterStrategy": { "index": 29, "kind": "property", "displayName": "Header Filter Strategy", "group": "filter", "label": "filter", "required": false, "type": "object", "javaType": "org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message." } + "autoDeclareProducer": { "index": 22, "kind": "property", "displayName": "Auto Declare Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether the producer should auto declare binding between exchange, queue and routing key when starting. Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker." }, + "lazyStartProducer": { "index": 23, "kind": "property", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, + "replyTimeout": { "index": 24, "kind": "property", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply messaging. The default value is 5 seconds. A negative value indicates an indefinite timeout." }, + "args": { "index": 25, "kind": "property", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: consumer. exchange. queue. binding. dlq.exchange. dlq.queue. dlq.binding. For example to declare a queue with message ttl argument: queue.x-message-ttl=60000" }, + "autowiredEnabled": { "index": 26, "kind": "property", "displayName": "Autowired Enabled", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc." }, + "ignoreDeclarationExceptions": { "index": 27, "kind": "property", "displayName": "Ignore Declaration Exceptions", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Switch on ignore exceptions such as mismatched properties when declaring" }, + "messageConverter": { "index": 28, "kind": "property", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, + "messagePropertiesConverter": { "index": 29, "kind": "property", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, + "headerFilterStrategy": { "index": 30, "kind": "property", "displayName": "Header Filter Strategy", "group": "filter", "label": "filter", "required": false, "type": "object", "javaType": "org.apache.camel.spi.HeaderFilterStrategy", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message." } }, "headers": { "CamelSpringRabbitmqRoutingOverrideKey": { "index": 0, "kind": "header", "displayName": "", "group": "producer", "label": "producer", "required": false, "javaType": "String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "To override the endpoint configuration's routing key.", "constantName": "org.apache.camel.component.springrabbit.SpringRabbitMQConstants#ROUTING_OVERRIDE_KEY" }, @@ -79,22 +80,22 @@ "properties": { "exchangeName": { "index": 0, "kind": "path", "displayName": "Exchange Name", "group": "common", "label": "", "required": true, "type": "string", "javaType": "java.lang.String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "The exchange name determines the exchange to which the produced messages will be sent to. In the case of consumers, the exchange name determines the exchange the queue will be bound to. Note: to use default exchange then do not use empty name, but use default instead." }, "connectionFactory": { "index": 1, "kind": "parameter", "displayName": "Connection Factory", "group": "common", "label": "common", "required": false, "type": "object", "javaType": "org.springframework.amqp.rabbit.connection.ConnectionFactory", "deprecated": false, "autowired": false, "secret": false, "description": "The connection factory to be use. A connection factory must be configured either on the component or endpoint." }, - "disableReplyTo": { "index": 2, "kind": "parameter", "displayName": "Disable Reply To", "group": "common", "label": "common", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether Camel ignores the ReplyTo header in messages. If true, Camel does not send a reply back to the destination specified in the ReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message brokers and you want to route message from one system to another." }, - "routingKey": { "index": 3, "kind": "parameter", "displayName": "Routing Key", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The value of a routing key to use. Default is empty which is not helpful when using the default (or any direct) exchange, but fine if the exchange is a headers exchange for instance." }, - "testConnectionOnStartup": { "index": 4, "kind": "parameter", "displayName": "Test Connection On Startup", "group": "common", "label": "", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well." }, - "acknowledgeMode": { "index": 5, "kind": "parameter", "displayName": "Acknowledge Mode", "group": "consumer", "label": "consumer", "required": false, "type": "object", "javaType": "org.springframework.amqp.core.AcknowledgeMode", "enum": [ "NONE", "MANUAL", "AUTO" ], "deprecated": false, "autowired": false, "secret": false, "description": "Flag controlling the behaviour of the container with respect to message acknowledgement. The most common usage is to let the container handle the acknowledgements (so the listener doesn't need to know about the channel or the message). Set to AcknowledgeMode.MANUAL if the listener will send the acknowledgements itself using Channel.basicAck(long, boolean). Manual acks are consistent with either a transactional or non-transactional channel, but if you are doing no other work on the channel at the same other than receiving a single message then the transaction is probably unnecessary. Set to AcknowledgeMode.NONE to tell the broker not to expect any acknowledgements, and it will assume all messages are acknowledged as soon as they are sent (this is autoack in native Rabbit broker terms). If AcknowledgeMode.NONE then the channel cannot be transactional (so the container will fail on start up if that flag is accidentally set)." }, - "asyncConsumer": { "index": 6, "kind": "parameter", "displayName": "Async Consumer", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the consumer processes the Exchange asynchronously. If enabled then the consumer may pickup the next message from the queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100% strictly in order. If disabled (as default) then the Exchange is fully processed before the consumer will pickup the next message from the queue." }, - "autoDeclare": { "index": 7, "kind": "parameter", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting." }, - "autoStartup": { "index": 8, "kind": "parameter", "displayName": "Auto Startup", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer container should auto-startup." }, - "deadLetterExchange": { "index": 9, "kind": "parameter", "displayName": "Dead Letter Exchange", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter exchange" }, - "deadLetterExchangeType": { "index": 10, "kind": "parameter", "displayName": "Dead Letter Exchange Type", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the dead letter exchange" }, - "deadLetterQueue": { "index": 11, "kind": "parameter", "displayName": "Dead Letter Queue", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter queue" }, - "deadLetterRoutingKey": { "index": 12, "kind": "parameter", "displayName": "Dead Letter Routing Key", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The routing key for the dead letter exchange" }, - "exchangeType": { "index": 13, "kind": "parameter", "displayName": "Exchange Type", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the exchange" }, - "exclusive": { "index": 14, "kind": "parameter", "displayName": "Exclusive", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an exclusive consumer" }, - "maximumRetryAttempts": { "index": 15, "kind": "parameter", "displayName": "Maximum Retry Attempts", "group": "consumer", "label": "consumer", "required": false, "type": "integer", "javaType": "int", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 5, "description": "How many times a Rabbitmq consumer will retry the same message if Camel failed to process the message" }, - "noLocal": { "index": 16, "kind": "parameter", "displayName": "No Local", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an no-local consumer" }, - "queues": { "index": 17, "kind": "parameter", "displayName": "Queues", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The queue(s) to use for consuming messages. Multiple queue names can be separated by comma. If none has been configured then Camel will generate an unique id as the queue name for the consumer." }, + "deadLetterExchange": { "index": 2, "kind": "parameter", "displayName": "Dead Letter Exchange", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter exchange" }, + "deadLetterExchangeType": { "index": 3, "kind": "parameter", "displayName": "Dead Letter Exchange Type", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the dead letter exchange" }, + "deadLetterQueue": { "index": 4, "kind": "parameter", "displayName": "Dead Letter Queue", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The name of the dead letter queue" }, + "deadLetterRoutingKey": { "index": 5, "kind": "parameter", "displayName": "Dead Letter Routing Key", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The routing key for the dead letter exchange" }, + "disableReplyTo": { "index": 6, "kind": "parameter", "displayName": "Disable Reply To", "group": "common", "label": "common", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether Camel ignores the ReplyTo header in messages. If true, Camel does not send a reply back to the destination specified in the ReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message brokers and you want to route message from one system to another." }, + "queues": { "index": 7, "kind": "parameter", "displayName": "Queues", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The queue(s) to use for consuming or producing messages. Multiple queue names can be separated by comma. If none has been configured then Camel will generate an unique id as the queue name." }, + "routingKey": { "index": 8, "kind": "parameter", "displayName": "Routing Key", "group": "common", "label": "common", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "autowired": false, "secret": false, "description": "The value of a routing key to use. Default is empty which is not helpful when using the default (or any direct) exchange, but fine if the exchange is a headers exchange for instance." }, + "testConnectionOnStartup": { "index": 9, "kind": "parameter", "displayName": "Test Connection On Startup", "group": "common", "label": "", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well." }, + "acknowledgeMode": { "index": 10, "kind": "parameter", "displayName": "Acknowledge Mode", "group": "consumer", "label": "consumer", "required": false, "type": "object", "javaType": "org.springframework.amqp.core.AcknowledgeMode", "enum": [ "NONE", "MANUAL", "AUTO" ], "deprecated": false, "autowired": false, "secret": false, "description": "Flag controlling the behaviour of the container with respect to message acknowledgement. The most common usage is to let the container handle the acknowledgements (so the listener doesn't need to know about the channel or the message). Set to AcknowledgeMode.MANUAL if the listener will send the acknowledgements itself using Channel.basicAck(long, boolean). Manual acks are consistent with either a transactional or non-transactional channel, but if you are doing no other work on the channel at the same other than receiving a single message then the transaction is probably unnecessary. Set to AcknowledgeMode.NONE to tell the broker not to expect any acknowledgements, and it will assume all messages are acknowledged as soon as they are sent (this is autoack in native Rabbit broker terms). If AcknowledgeMode.NONE then the channel cannot be transactional (so the container will fail on start up if that flag is accidentally set)." }, + "asyncConsumer": { "index": 11, "kind": "parameter", "displayName": "Async Consumer", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the consumer processes the Exchange asynchronously. If enabled then the consumer may pickup the next message from the queue, while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100% strictly in order. If disabled (as default) then the Exchange is fully processed before the consumer will pickup the next message from the queue." }, + "autoDeclare": { "index": 12, "kind": "parameter", "displayName": "Auto Declare", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting." }, + "autoStartup": { "index": 13, "kind": "parameter", "displayName": "Auto Startup", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Specifies whether the consumer container should auto-startup." }, + "exchangeType": { "index": 14, "kind": "parameter", "displayName": "Exchange Type", "group": "consumer", "label": "consumer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "direct", "fanout", "headers", "topic" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "direct", "description": "The type of the exchange" }, + "exclusive": { "index": 15, "kind": "parameter", "displayName": "Exclusive", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an exclusive consumer" }, + "maximumRetryAttempts": { "index": 16, "kind": "parameter", "displayName": "Maximum Retry Attempts", "group": "consumer", "label": "consumer", "required": false, "type": "integer", "javaType": "int", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 5, "description": "How many times a Rabbitmq consumer will retry the same message if Camel failed to process the message" }, + "noLocal": { "index": 17, "kind": "parameter", "displayName": "No Local", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Set to true for an no-local consumer" }, "rejectAndDontRequeue": { "index": 18, "kind": "parameter", "displayName": "Reject And Dont Requeue", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether a Rabbitmq consumer should reject the message without requeuing. This enables failed messages to be sent to a Dead Letter Exchange\/Queue, if the broker is so configured." }, "retryDelay": { "index": 19, "kind": "parameter", "displayName": "Retry Delay", "group": "consumer", "label": "consumer", "required": false, "type": "integer", "javaType": "int", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 1000, "description": "Delay in millis a Rabbitmq consumer will wait before redelivering a message that Camel failed to process" }, "bridgeErrorHandler": { "index": 20, "kind": "parameter", "displayName": "Bridge Error Handler", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored." }, @@ -106,14 +107,15 @@ "prefetchCount": { "index": 26, "kind": "parameter", "displayName": "Prefetch Count", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "integer", "javaType": "java.lang.Integer", "deprecated": false, "autowired": false, "secret": false, "description": "Tell the broker how many messages to send in a single request. Often this can be set quite high to improve throughput." }, "retry": { "index": 27, "kind": "parameter", "displayName": "Retry", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.springframework.retry.interceptor.RetryOperationsInterceptor", "deprecated": false, "autowired": false, "secret": false, "description": "Custom retry configuration to use. If this is configured then the other settings such as maximumRetryAttempts for retry are not in use." }, "allowNullBody": { "index": 28, "kind": "parameter", "displayName": "Allow Null Body", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether to allow sending messages with no body. If this option is false and the message body is null, then an MessageConversionException is thrown." }, - "confirm": { "index": 29, "kind": "parameter", "displayName": "Confirm", "group": "producer", "label": "producer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "auto", "enabled", "disabled" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "auto", "description": "Controls whether to wait for confirms. The connection factory must be configured for publisher confirms and this method. auto = Camel detects if the connection factory uses confirms or not. disabled = Confirms is disabled. enabled = Confirms is enabled." }, - "confirmTimeout": { "index": 30, "kind": "parameter", "displayName": "Confirm Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a message sent to be confirmed by RabbitMQ when doing send only messaging (InOnly). The default value is 5 seconds. A negative value indicates an indefinite timeout." }, - "replyTimeout": { "index": 31, "kind": "parameter", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "30000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply (InOut) messaging. The default value is 30 seconds. A negative value indicates an indefinite timeout (Beware that this will cause a memory leak if a reply is not received)." }, - "usePublisherConnection": { "index": 32, "kind": "parameter", "displayName": "Use Publisher Connection", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Use a separate connection for publishers and consumers" }, - "lazyStartProducer": { "index": 33, "kind": "parameter", "displayName": "Lazy Start Producer", "group": "producer (advanced)", "label": "producer,advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, - "args": { "index": 34, "kind": "parameter", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "prefix": "arg.", "multiValue": true, "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: arg.consumer. arg.exchange. arg.queue. arg.binding. arg.dlq.exchange. arg.dlq.queue. arg.dlq.binding. For example to declare a queue with message ttl argument: args=arg.queue.x-message-ttl=60000" }, - "messageConverter": { "index": 35, "kind": "parameter", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, - "messagePropertiesConverter": { "index": 36, "kind": "parameter", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, - "synchronous": { "index": 37, "kind": "parameter", "displayName": "Synchronous", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Sets whether synchronous processing should be strictly used" } + "autoDeclareProducer": { "index": 29, "kind": "parameter", "displayName": "Auto Declare Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Specifies whether the producer should auto declare binding between exchange, queue and routing key when starting." }, + "confirm": { "index": 30, "kind": "parameter", "displayName": "Confirm", "group": "producer", "label": "producer", "required": false, "type": "string", "javaType": "java.lang.String", "enum": [ "auto", "enabled", "disabled" ], "deprecated": false, "autowired": false, "secret": false, "defaultValue": "auto", "description": "Controls whether to wait for confirms. The connection factory must be configured for publisher confirms and this method. auto = Camel detects if the connection factory uses confirms or not. disabled = Confirms is disabled. enabled = Confirms is enabled." }, + "confirmTimeout": { "index": 31, "kind": "parameter", "displayName": "Confirm Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "5000", "description": "Specify the timeout in milliseconds to be used when waiting for a message sent to be confirmed by RabbitMQ when doing send only messaging (InOnly). The default value is 5 seconds. A negative value indicates an indefinite timeout." }, + "replyTimeout": { "index": 32, "kind": "parameter", "displayName": "Reply Timeout", "group": "producer", "label": "producer", "required": false, "type": "duration", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": "30000", "description": "Specify the timeout in milliseconds to be used when waiting for a reply message when doing request\/reply (InOut) messaging. The default value is 30 seconds. A negative value indicates an indefinite timeout (Beware that this will cause a memory leak if a reply is not received)." }, + "usePublisherConnection": { "index": 33, "kind": "parameter", "displayName": "Use Publisher Connection", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Use a separate connection for publishers and consumers" }, + "lazyStartProducer": { "index": 34, "kind": "parameter", "displayName": "Lazy Start Producer", "group": "producer (advanced)", "label": "producer,advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing." }, + "args": { "index": 35, "kind": "parameter", "displayName": "Args", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "java.util.Map", "prefix": "arg.", "multiValue": true, "deprecated": false, "autowired": false, "secret": false, "description": "Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each element: arg.consumer. arg.exchange. arg.queue. arg.binding. arg.dlq.exchange. arg.dlq.queue. arg.dlq.binding. For example to declare a queue with message ttl argument: args=arg.queue.x-message-ttl=60000" }, + "messageConverter": { "index": 36, "kind": "parameter", "displayName": "Message Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.springframework.amqp.support.converter.MessageConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessageConverter so you can be in control how to map to\/from a org.springframework.amqp.core.Message." }, + "messagePropertiesConverter": { "index": 37, "kind": "parameter", "displayName": "Message Properties Converter", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.springrabbit.MessagePropertiesConverter", "deprecated": false, "autowired": false, "secret": false, "description": "To use a custom MessagePropertiesConverter so you can be in control how to map to\/from a org.springframework.amqp.core.MessageProperties." }, + "synchronous": { "index": 38, "kind": "parameter", "displayName": "Synchronous", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Sets whether synchronous processing should be strictly used" } } } diff --git a/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponent.java b/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponent.java index e797d780b03d0..9610ef00e6ed4 100644 --- a/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponent.java +++ b/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQComponent.java @@ -53,10 +53,14 @@ public class SpringRabbitMQComponent extends HeaderFilterStrategyComponent { @Metadata(label = "consumer", defaultValue = "true", description = "Specifies whether the consumer container should auto-startup.") private boolean autoStartup = true; - @Metadata(label = "consumer", defaultValue = "false", + @Metadata(label = "consumer", defaultValue = "true", description = "Specifies whether the consumer should auto declare binding between exchange, queue and routing key when starting." + " Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker.") - private boolean autoDeclare; + private boolean autoDeclare = true; + @Metadata(label = "producer", defaultValue = "false", + description = "Specifies whether the producer should auto declare binding between exchange, queue and routing key when starting." + + " Enabling this can be good for development to make it easy to standup exchanges, queues and bindings on the broker.") + private boolean autoDeclareProducer; @Metadata(label = "advanced", description = "To use a custom MessageConverter so you can be in control how to map to/from a org.springframework.amqp.core.Message.") private MessageConverter messageConverter; @@ -144,6 +148,7 @@ protected Endpoint createEndpoint(String uri, String remaining, Map args, String key, String de } public void declareElements(AbstractMessageListenerContainer container) { - AmqpAdmin admin = null; if (container instanceof MessageListenerContainer) { - admin = ((MessageListenerContainer) container).getAmqpAdmin(); + AmqpAdmin admin = ((MessageListenerContainer) container).getAmqpAdmin(); + declareElements(container, admin); } + } + + public void declareElements(AbstractMessageListenerContainer container, AmqpAdmin admin) { if (admin != null && autoDeclare) { // bind dead letter exchange if (deadLetterExchange != null) { @@ -711,7 +725,7 @@ public void declareElements(AbstractMessageListenerContainer container) { String qn = admin.declareQueue(rabbitQueue); // if we auto created a new unique queue then the container needs to know the queue name - if (generateUniqueQueue) { + if (generateUniqueQueue && container != null) { container.setQueueNames(qn); } diff --git a/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQProducer.java b/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQProducer.java index 73712e16f8c9f..59f05bfa21e70 100644 --- a/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQProducer.java +++ b/components/camel-spring-rabbitmq/src/main/java/org/apache/camel/component/springrabbit/SpringRabbitMQProducer.java @@ -27,12 +27,14 @@ import org.apache.camel.support.DefaultAsyncProducer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.amqp.core.AmqpAdmin; import org.springframework.amqp.core.Message; import org.springframework.amqp.core.MessageProperties; import org.springframework.amqp.rabbit.AsyncRabbitTemplate; import org.springframework.amqp.rabbit.RabbitMessageFuture; import org.springframework.amqp.rabbit.connection.Connection; import org.springframework.amqp.rabbit.connection.RabbitUtils; +import org.springframework.amqp.rabbit.core.RabbitAdmin; import org.springframework.amqp.rabbit.core.RabbitTemplate; public class SpringRabbitMQProducer extends DefaultAsyncProducer { @@ -80,6 +82,16 @@ protected void doStart() throws Exception { if (getEndpoint().isTestConnectionOnStartup()) { testConnectionOnStartup(); } + if (getEndpoint().isAutoDeclareProducer()) { + // auto declare but without spring + AmqpAdmin admin = getEndpoint().getComponent().getAmqpAdmin(); + if (admin == null) { + RabbitAdmin ra = new RabbitAdmin(getEndpoint().getConnectionFactory()); + ra.setIgnoreDeclarationExceptions(getEndpoint().getComponent().isIgnoreDeclarationExceptions()); + admin = ra; + } + getEndpoint().declareElements(null, admin); + } } @Override diff --git a/components/camel-spring-rabbitmq/src/test/java/org/apache/camel/component/springrabbit/integration/RabbitMQProducerAutoDeclareIT.java b/components/camel-spring-rabbitmq/src/test/java/org/apache/camel/component/springrabbit/integration/RabbitMQProducerAutoDeclareIT.java new file mode 100644 index 0000000000000..b932c776f064e --- /dev/null +++ b/components/camel-spring-rabbitmq/src/test/java/org/apache/camel/component/springrabbit/integration/RabbitMQProducerAutoDeclareIT.java @@ -0,0 +1,122 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.springrabbit.integration; + +import java.nio.charset.Charset; +import java.util.Map; + +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.springrabbit.SpringRabbitMQConstants; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.amqp.core.AmqpTemplate; +import org.springframework.amqp.core.Message; +import org.springframework.amqp.core.MessageBuilder; +import org.springframework.amqp.core.MessageDeliveryMode; +import org.springframework.amqp.core.MessageProperties; +import org.springframework.amqp.core.MessagePropertiesBuilder; +import org.springframework.amqp.rabbit.connection.ConnectionFactory; +import org.springframework.amqp.rabbit.core.RabbitTemplate; + +public class RabbitMQProducerAutoDeclareIT extends RabbitMQITSupport { + + @Test + public void testProducer() throws Exception { + ConnectionFactory cf = context.getRegistry().lookupByNameAndType("myCF", ConnectionFactory.class); + + template.sendBody("direct:start", "Hello World"); + + AmqpTemplate template = new RabbitTemplate(cf); + String out = (String) template.receiveAndConvert("myqueue"); + Assertions.assertEquals("Hello World", out); + } + + @Test + public void testProducerWithHeader() throws Exception { + ConnectionFactory cf = context.getRegistry().lookupByNameAndType("myCF", ConnectionFactory.class); + + template.sendBodyAndHeader("direct:start", "Hello World", "cheese", "gouda"); + + AmqpTemplate template = new RabbitTemplate(cf); + Message out = template.receive("myqueue"); + + byte[] body = out.getBody(); + Assertions.assertNotNull(body, "The body should not be null"); + Assertions.assertEquals("Hello World", new String(body)); + Assertions.assertEquals("gouda", out.getMessageProperties().getHeader("cheese")); + } + + @Test + public void testProducerWithMessage() throws Exception { + ConnectionFactory cf = context.getRegistry().lookupByNameAndType("myCF", ConnectionFactory.class); + + MessageProperties props = MessagePropertiesBuilder.newInstance() + .setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN) + .setMessageId("123") + .setHeader("bar", "baz") + .build(); + Message body = MessageBuilder.withBody("foo".getBytes()) + .andProperties(props) + .build(); + + template.sendBody("direct:start", body); + + AmqpTemplate template = new RabbitTemplate(cf); + Message out = template.receive("myqueue"); + Assertions.assertEquals("foo", new String(out.getBody())); + Assertions.assertEquals("baz", out.getMessageProperties().getHeader("bar")); + } + + @Test + public void testProducerWithMessageProperties() throws Exception { + ConnectionFactory cf = context.getRegistry().lookupByNameAndType("myCF", ConnectionFactory.class); + + template.sendBodyAndHeaders("direct:start", "123", + Map.of(SpringRabbitMQConstants.DELIVERY_MODE, MessageDeliveryMode.PERSISTENT, + SpringRabbitMQConstants.TYPE, "price", + SpringRabbitMQConstants.CONTENT_TYPE, "application/xml", + SpringRabbitMQConstants.MESSAGE_ID, "0fe9c142-f9c1-426f-9237-f5a4c988a8ae", + SpringRabbitMQConstants.PRIORITY, 1)); + + AmqpTemplate template = new RabbitTemplate(cf); + Message out = template.receive("myqueue"); + + final MessageProperties messageProperties = out.getMessageProperties(); + Assertions.assertNotNull(messageProperties, "The message properties should not be null"); + String encoding = messageProperties.getContentEncoding(); + Assertions.assertEquals(Charset.defaultCharset().name(), encoding); + Assertions.assertEquals("123", new String(out.getBody(), encoding)); + Assertions.assertEquals(MessageDeliveryMode.PERSISTENT, messageProperties.getReceivedDeliveryMode()); + Assertions.assertEquals("price", messageProperties.getType()); + Assertions.assertEquals("application/xml", messageProperties.getContentType()); + Assertions.assertEquals("0fe9c142-f9c1-426f-9237-f5a4c988a8ae", messageProperties.getMessageId()); + Assertions.assertEquals(1, messageProperties.getPriority()); + Assertions.assertEquals(0, messageProperties.getHeaders().size()); + } + + @Override + protected RoutesBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + from("direct:start") + .to("spring-rabbitmq:foo?autoDeclareProducer=true&routingKey=foo.bar.#&queues=myqueue&exchangeType=topic"); + } + }; + } +} diff --git a/components/camel-spring-rabbitmq/src/test/java/org/apache/camel/component/springrabbit/integration/RabbitMQProducerSimpleIT.java b/components/camel-spring-rabbitmq/src/test/java/org/apache/camel/component/springrabbit/integration/RabbitMQProducerSimpleIT.java new file mode 100644 index 0000000000000..e479a1c97c3d8 --- /dev/null +++ b/components/camel-spring-rabbitmq/src/test/java/org/apache/camel/component/springrabbit/integration/RabbitMQProducerSimpleIT.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.springrabbit.integration; + +import org.apache.camel.RoutesBuilder; +import org.apache.camel.builder.RouteBuilder; +import org.junit.jupiter.api.Test; + +public class RabbitMQProducerSimpleIT extends RabbitMQITSupport { + + @Test + public void testProducer() throws Exception { + template.sendBody("direct:start", "Hello World"); + } + + @Override + protected RoutesBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + from("direct:start") + .to("spring-rabbitmq:simple"); + } + }; + } +} diff --git a/dsl/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRabbitmqComponentBuilderFactory.java b/dsl/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRabbitmqComponentBuilderFactory.java index c517e611dd7a4..85a8fda1d104f 100644 --- a/dsl/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRabbitmqComponentBuilderFactory.java +++ b/dsl/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRabbitmqComponentBuilderFactory.java @@ -113,7 +113,7 @@ default SpringRabbitmqComponentBuilder testConnectionOnStartup( * * The option is a: <code>boolean</code> type. * - * Default: false + * Default: true * Group: consumer * * @param autoDeclare the value to set @@ -429,6 +429,25 @@ default SpringRabbitmqComponentBuilder allowNullBody( doSetProperty("allowNullBody", allowNullBody); return this; } + /** + * Specifies whether the producer should auto declare binding between + * exchange, queue and routing key when starting. Enabling this can be + * good for development to make it easy to standup exchanges, queues and + * bindings on the broker. + * + * The option is a: <code>boolean</code> type. + * + * Default: false + * Group: producer + * + * @param autoDeclareProducer the value to set + * @return the dsl builder + */ + default SpringRabbitmqComponentBuilder autoDeclareProducer( + boolean autoDeclareProducer) { + doSetProperty("autoDeclareProducer", autoDeclareProducer); + return this; + } /** * Whether the producer should be started lazy (on the first message). * By starting lazy you can use this to allow CamelContext and routes to @@ -618,6 +637,7 @@ protected boolean setPropertyOnComponent( case "retry": ((SpringRabbitMQComponent) component).setRetry((org.springframework.retry.interceptor.RetryOperationsInterceptor) value); return true; case "shutdownTimeout": ((SpringRabbitMQComponent) component).setShutdownTimeout((long) value); return true; case "allowNullBody": ((SpringRabbitMQComponent) component).setAllowNullBody((boolean) value); return true; + case "autoDeclareProducer": ((SpringRabbitMQComponent) component).setAutoDeclareProducer((boolean) value); return true; case "lazyStartProducer": ((SpringRabbitMQComponent) component).setLazyStartProducer((boolean) value); return true; case "replyTimeout": ((SpringRabbitMQComponent) component).setReplyTimeout((long) value); return true; case "args": ((SpringRabbitMQComponent) component).setArgs((java.util.Map) value); return true; diff --git a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/SpringRabbitMQEndpointBuilderFactory.java b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/SpringRabbitMQEndpointBuilderFactory.java index 5ff2b0488a315..49311462da8db 100644 --- a/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/SpringRabbitMQEndpointBuilderFactory.java +++ b/dsl/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/SpringRabbitMQEndpointBuilderFactory.java @@ -78,6 +78,67 @@ default SpringRabbitMQEndpointConsumerBuilder connectionFactory( doSetProperty("connectionFactory", connectionFactory); return this; } + /** + * The name of the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterExchange the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointConsumerBuilder deadLetterExchange( + String deadLetterExchange) { + doSetProperty("deadLetterExchange", deadLetterExchange); + return this; + } + /** + * The type of the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Default: direct + * Group: common + * + * @param deadLetterExchangeType the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointConsumerBuilder deadLetterExchangeType( + String deadLetterExchangeType) { + doSetProperty("deadLetterExchangeType", deadLetterExchangeType); + return this; + } + /** + * The name of the dead letter queue. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterQueue the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointConsumerBuilder deadLetterQueue( + String deadLetterQueue) { + doSetProperty("deadLetterQueue", deadLetterQueue); + return this; + } + /** + * The routing key for the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterRoutingKey the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointConsumerBuilder deadLetterRoutingKey( + String deadLetterRoutingKey) { + doSetProperty("deadLetterRoutingKey", deadLetterRoutingKey); + return this; + } /** * Specifies whether Camel ignores the ReplyTo header in messages. If * true, Camel does not send a reply back to the destination specified @@ -125,6 +186,22 @@ default SpringRabbitMQEndpointConsumerBuilder disableReplyTo( doSetProperty("disableReplyTo", disableReplyTo); return this; } + /** + * The queue(s) to use for consuming or producing messages. Multiple + * queue names can be separated by comma. If none has been configured + * then Camel will generate an unique id as the queue name. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param queues the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointConsumerBuilder queues(String queues) { + doSetProperty("queues", queues); + return this; + } /** * The value of a routing key to use. Default is empty which is not * helpful when using the default (or any direct) exchange, but fine if @@ -356,67 +433,6 @@ default SpringRabbitMQEndpointConsumerBuilder autoStartup( doSetProperty("autoStartup", autoStartup); return this; } - /** - * The name of the dead letter exchange. - * - * The option is a: <code>java.lang.String</code> type. - * - * Group: consumer - * - * @param deadLetterExchange the value to set - * @return the dsl builder - */ - default SpringRabbitMQEndpointConsumerBuilder deadLetterExchange( - String deadLetterExchange) { - doSetProperty("deadLetterExchange", deadLetterExchange); - return this; - } - /** - * The type of the dead letter exchange. - * - * The option is a: <code>java.lang.String</code> type. - * - * Default: direct - * Group: consumer - * - * @param deadLetterExchangeType the value to set - * @return the dsl builder - */ - default SpringRabbitMQEndpointConsumerBuilder deadLetterExchangeType( - String deadLetterExchangeType) { - doSetProperty("deadLetterExchangeType", deadLetterExchangeType); - return this; - } - /** - * The name of the dead letter queue. - * - * The option is a: <code>java.lang.String</code> type. - * - * Group: consumer - * - * @param deadLetterQueue the value to set - * @return the dsl builder - */ - default SpringRabbitMQEndpointConsumerBuilder deadLetterQueue( - String deadLetterQueue) { - doSetProperty("deadLetterQueue", deadLetterQueue); - return this; - } - /** - * The routing key for the dead letter exchange. - * - * The option is a: <code>java.lang.String</code> type. - * - * Group: consumer - * - * @param deadLetterRoutingKey the value to set - * @return the dsl builder - */ - default SpringRabbitMQEndpointConsumerBuilder deadLetterRoutingKey( - String deadLetterRoutingKey) { - doSetProperty("deadLetterRoutingKey", deadLetterRoutingKey); - return this; - } /** * The type of the exchange. * @@ -530,22 +546,6 @@ default SpringRabbitMQEndpointConsumerBuilder noLocal(String noLocal) { doSetProperty("noLocal", noLocal); return this; } - /** - * The queue(s) to use for consuming messages. Multiple queue names can - * be separated by comma. If none has been configured then Camel will - * generate an unique id as the queue name for the consumer. - * - * The option is a: <code>java.lang.String</code> type. - * - * Group: consumer - * - * @param queues the value to set - * @return the dsl builder - */ - default SpringRabbitMQEndpointConsumerBuilder queues(String queues) { - doSetProperty("queues", queues); - return this; - } /** * Whether a Rabbitmq consumer should reject the message without * requeuing. This enables failed messages to be sent to a Dead Letter @@ -1090,6 +1090,67 @@ default SpringRabbitMQEndpointProducerBuilder connectionFactory( doSetProperty("connectionFactory", connectionFactory); return this; } + /** + * The name of the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterExchange the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointProducerBuilder deadLetterExchange( + String deadLetterExchange) { + doSetProperty("deadLetterExchange", deadLetterExchange); + return this; + } + /** + * The type of the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Default: direct + * Group: common + * + * @param deadLetterExchangeType the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointProducerBuilder deadLetterExchangeType( + String deadLetterExchangeType) { + doSetProperty("deadLetterExchangeType", deadLetterExchangeType); + return this; + } + /** + * The name of the dead letter queue. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterQueue the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointProducerBuilder deadLetterQueue( + String deadLetterQueue) { + doSetProperty("deadLetterQueue", deadLetterQueue); + return this; + } + /** + * The routing key for the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterRoutingKey the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointProducerBuilder deadLetterRoutingKey( + String deadLetterRoutingKey) { + doSetProperty("deadLetterRoutingKey", deadLetterRoutingKey); + return this; + } /** * Specifies whether Camel ignores the ReplyTo header in messages. If * true, Camel does not send a reply back to the destination specified @@ -1137,6 +1198,22 @@ default SpringRabbitMQEndpointProducerBuilder disableReplyTo( doSetProperty("disableReplyTo", disableReplyTo); return this; } + /** + * The queue(s) to use for consuming or producing messages. Multiple + * queue names can be separated by comma. If none has been configured + * then Camel will generate an unique id as the queue name. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param queues the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointProducerBuilder queues(String queues) { + doSetProperty("queues", queues); + return this; + } /** * The value of a routing key to use. Default is empty which is not * helpful when using the default (or any direct) exchange, but fine if @@ -1232,6 +1309,41 @@ default SpringRabbitMQEndpointProducerBuilder allowNullBody( doSetProperty("allowNullBody", allowNullBody); return this; } + /** + * Specifies whether the producer should auto declare binding between + * exchange, queue and routing key when starting. + * + * The option is a: <code>boolean</code> type. + * + * Default: false + * Group: producer + * + * @param autoDeclareProducer the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointProducerBuilder autoDeclareProducer( + boolean autoDeclareProducer) { + doSetProperty("autoDeclareProducer", autoDeclareProducer); + return this; + } + /** + * Specifies whether the producer should auto declare binding between + * exchange, queue and routing key when starting. + * + * The option will be converted to a <code>boolean</code> + * type. + * + * Default: false + * Group: producer + * + * @param autoDeclareProducer the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointProducerBuilder autoDeclareProducer( + String autoDeclareProducer) { + doSetProperty("autoDeclareProducer", autoDeclareProducer); + return this; + } /** * Controls whether to wait for confirms. The connection factory must be * configured for publisher confirms and this method. auto = Camel @@ -1616,6 +1728,67 @@ default SpringRabbitMQEndpointBuilder connectionFactory( doSetProperty("connectionFactory", connectionFactory); return this; } + /** + * The name of the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterExchange the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointBuilder deadLetterExchange( + String deadLetterExchange) { + doSetProperty("deadLetterExchange", deadLetterExchange); + return this; + } + /** + * The type of the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Default: direct + * Group: common + * + * @param deadLetterExchangeType the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointBuilder deadLetterExchangeType( + String deadLetterExchangeType) { + doSetProperty("deadLetterExchangeType", deadLetterExchangeType); + return this; + } + /** + * The name of the dead letter queue. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterQueue the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointBuilder deadLetterQueue( + String deadLetterQueue) { + doSetProperty("deadLetterQueue", deadLetterQueue); + return this; + } + /** + * The routing key for the dead letter exchange. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param deadLetterRoutingKey the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointBuilder deadLetterRoutingKey( + String deadLetterRoutingKey) { + doSetProperty("deadLetterRoutingKey", deadLetterRoutingKey); + return this; + } /** * Specifies whether Camel ignores the ReplyTo header in messages. If * true, Camel does not send a reply back to the destination specified @@ -1663,6 +1836,22 @@ default SpringRabbitMQEndpointBuilder disableReplyTo( doSetProperty("disableReplyTo", disableReplyTo); return this; } + /** + * The queue(s) to use for consuming or producing messages. Multiple + * queue names can be separated by comma. If none has been configured + * then Camel will generate an unique id as the queue name. + * + * The option is a: <code>java.lang.String</code> type. + * + * Group: common + * + * @param queues the value to set + * @return the dsl builder + */ + default SpringRabbitMQEndpointBuilder queues(String queues) { + doSetProperty("queues", queues); + return this; + } /** * The value of a routing key to use. Default is empty which is not * helpful when using the default (or any direct) exchange, but fine if diff --git a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/SpringRabbitmqUriDsl.kt b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/SpringRabbitmqUriDsl.kt index c5e7f35184b6e..40c79b496abb2 100644 --- a/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/SpringRabbitmqUriDsl.kt +++ b/dsl/camel-kotlin-api/src/generated/kotlin/org/apache/camel/kotlin/components/SpringRabbitmqUriDsl.kt @@ -49,6 +49,22 @@ public class SpringRabbitmqUriDsl( it.property("connectionFactory", connectionFactory) } + public fun deadLetterExchange(deadLetterExchange: String) { + it.property("deadLetterExchange", deadLetterExchange) + } + + public fun deadLetterExchangeType(deadLetterExchangeType: String) { + it.property("deadLetterExchangeType", deadLetterExchangeType) + } + + public fun deadLetterQueue(deadLetterQueue: String) { + it.property("deadLetterQueue", deadLetterQueue) + } + + public fun deadLetterRoutingKey(deadLetterRoutingKey: String) { + it.property("deadLetterRoutingKey", deadLetterRoutingKey) + } + public fun disableReplyTo(disableReplyTo: String) { it.property("disableReplyTo", disableReplyTo) } @@ -57,6 +73,10 @@ public class SpringRabbitmqUriDsl( it.property("disableReplyTo", disableReplyTo.toString()) } + public fun queues(queues: String) { + it.property("queues", queues) + } + public fun routingKey(routingKey: String) { it.property("routingKey", routingKey) } @@ -97,22 +117,6 @@ public class SpringRabbitmqUriDsl( it.property("autoStartup", autoStartup.toString()) } - public fun deadLetterExchange(deadLetterExchange: String) { - it.property("deadLetterExchange", deadLetterExchange) - } - - public fun deadLetterExchangeType(deadLetterExchangeType: String) { - it.property("deadLetterExchangeType", deadLetterExchangeType) - } - - public fun deadLetterQueue(deadLetterQueue: String) { - it.property("deadLetterQueue", deadLetterQueue) - } - - public fun deadLetterRoutingKey(deadLetterRoutingKey: String) { - it.property("deadLetterRoutingKey", deadLetterRoutingKey) - } - public fun exchangeType(exchangeType: String) { it.property("exchangeType", exchangeType) } @@ -141,10 +145,6 @@ public class SpringRabbitmqUriDsl( it.property("noLocal", noLocal.toString()) } - public fun queues(queues: String) { - it.property("queues", queues) - } - public fun rejectAndDontRequeue(rejectAndDontRequeue: String) { it.property("rejectAndDontRequeue", rejectAndDontRequeue) } @@ -217,6 +217,14 @@ public class SpringRabbitmqUriDsl( it.property("allowNullBody", allowNullBody.toString()) } + public fun autoDeclareProducer(autoDeclareProducer: String) { + it.property("autoDeclareProducer", autoDeclareProducer) + } + + public fun autoDeclareProducer(autoDeclareProducer: Boolean) { + it.property("autoDeclareProducer", autoDeclareProducer.toString()) + } + public fun confirm(confirm: String) { it.property("confirm", confirm) }