Apache Camel route with xa transaction, multiple brokers & control bus - apache-camel

Question

I have 2 brokers hosted on different physical machines. I need to write camel route which will pick up message from inbound queue of broker-1 & send it to outbound queue configured in broker-2. Now if in any case broker-2 goes down then the traffic should be routed to a 3rd broker. As this will be a distributed transaction so I guess XA transaction(Springboot Atomikos) need to be used & for traffic diversion to 3rd broker, control bus eip to be used. But as I am new to camel so not sure how to do this..can anyone please guide me?
POM
<dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-core</artifactId>
<version>3.7.0</version>
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-jms</artifactId>
<version>3.7.0</version>
</dependency>
<!-- <dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-resilience4j</artifactId>
<version>3.4.5</version>use the same version as your Camel core version
</dependency> -->
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-resilience4j-starter</artifactId>
<version>3.7.0</version>
</dependency>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-camel</artifactId>
</dependency>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-broker</artifactId>
</dependency>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-client</artifactId>
</dependency>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-pool</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jta-atomikos -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>
Config
#Configuration
public class JMSConfigManager {
#Bean(name = "activemq1")
public ActiveMQComponent createComponent1(ConnectionFactory factory, JtaTransactionManager jtaTransactionManager) {
ActiveMQComponent activeMQComponent = new ActiveMQComponent();
activeMQComponent.setConnectionFactory(jmsConnectionFactory1());
activeMQComponent.setTransactionManager(jtaTransactionManager);
//activeMQComponent.setLazyCreateTransactionManager(false);
activeMQComponent.setCacheLevelName("CACHE_CONSUMER");
activeMQComponent.setTransacted(false);
activeMQComponent.setDeliveryPersistent(true);
//activeMQComponent.setTransactionName("PROPAGATION_REQUIRED");
activeMQComponent.setAcknowledgementMode(JmsProperties.AcknowledgeMode.CLIENT.getMode());
return activeMQComponent;
}
#Bean(name = "activemq2")
public ActiveMQComponent createComponent2(ConnectionFactory factory, JtaTransactionManager jtaTransactionManager) {
ActiveMQComponent activeMQComponent = new ActiveMQComponent();
activeMQComponent.setConnectionFactory(jmsConnectionFactory2());
//activeMQComponent.setLazyCreateTransactionManager(false);
activeMQComponent.setCacheLevelName("CACHE_CONSUMER");
activeMQComponent.setTransactionManager(jtaTransactionManager);
activeMQComponent.setTransacted(false);
activeMQComponent.setDeliveryPersistent(true);
//activeMQComponent.setTransactionName("PROPAGATION_REQUIRED");
activeMQComponent.setAcknowledgementMode(JmsProperties.AcknowledgeMode.CLIENT.getMode());
return activeMQComponent;
}
#Primary
#Bean(name = "cf1") public ConnectionFactory jmsConnectionFactory1() {
ActiveMQConnectionFactory connectionFactory = new
ActiveMQConnectionFactory();
connectionFactory.setBrokerURL("tcp://localhost:61616");
return connectionFactory;
}
#Bean(name = "cf2") public ConnectionFactory jmsConnectionFactory2() {
ActiveMQConnectionFactory connectionFactory = new
ActiveMQConnectionFactory();
connectionFactory.setBrokerURL("tcp://localhost:61617");
return connectionFactory;
}
Policy
#Configuration
public class TransactionConfig {
#Bean("policyPropagationRequired")
public SpringTransactionPolicy transactionPolicyPropagationRequired(
#Autowired JtaTransactionManager transactionmanager) {
SpringTransactionPolicy policy = new SpringTransactionPolicy(transactionmanager);
policy.setPropagationBehaviorName("PROPAGATION_REQUIRED");
return policy;
}
}
Route
#Override
public void configure() throws Exception {
System.out.println("Test-1");
from("jms:INBOUND.Q?connectionFactory=cf1")
.transacted("policyPropagationRequired")
//.log(LoggingLevel.INFO, log, "******Inbound messages Received")
.to("jms:OUTBOUND.Q1?connectionFactory=cf2")
.end();
}

Answer 1

As this will be a distributed transaction so I guess XA transaction(Springboot Atomikos) need to be used
It depends:
If you want a "water-proof" end-to-end-transaction between the brokers, you need to use XA-transactions
If you are OK with a "duplicates-possible transaction", you can simplify the setup and only use local consumer transaction of the broker
To clarify the last point: if you consume with local broker transaction, Camel does not commit the message on the consumer until the route is successfully processed. So if any error occurs, a rollback would happen and the message would be redelivered.
The consequence is an edge-case where a message can be successfully sent to the destination broker, but Camel is no more able to commit against the source broker. Then a redelivery occurs, the route is processed one more time and the same message is delivered two (or more) times.
So the choice is to either use XA transactions or consumer transactions with an idempotent consumer (that compensates the mentioned edge case).
for traffic diversion to 3rd broker, control bus eip to be used
Can't you simply use the Camel error handling to route to broker 3 instead of broker 2?
And another strategy would be to build some kind of broker cluster (real cluster, network of brokers or whatever) that encapsulates the failover from broker 2 to broker 3.