Camel RaabitMQ Acknowledgement

Question

I am using Camel for my messaging application. In my use case I have a producer (which is RabbitMQ here), and the Consumer is a bean.

from("rabbitmq://127.0.0.1:5672/exDemo?queue=testQueue&username=guest&password=guest&autoAck=false&durable=true&exchangeType=direct&autoDelete=false")
                .throttle(100).timePeriodMillis(10000)
                .process(new Processor() {                              
                        @Override
                        public void process(Exchange exchange) throws Exception {
                            MyCustomConsumer.consume(exchange.getIn().getBody())
                        }
                    });

Apparently, when autoAck is false, acknowledgement is sent when the process() execution is finished (please correct me if I am wrong here)

Now I don't want to acknowledge when the process() execution is finished, I want to do it at a later stage. I have a BlockingQueue in my MyCustomConsumer where consume() is putting messages, and MyCustomConsumer has different mechanism to process them. I want to acknowledge message only when MyCustomConsumer finishes processing messages from BlockingQueue. How can I achieve this?

Answer 1

You can consider to use the camel AsyncProcessor API to call the callback done once you processing the message from BlockingQueue.

Answer 2

I bumped into the same issue.

The Camel RabbitMQConsumer.RabbitConsumer implementation does

consumer.getProcessor().process(exchange);

long deliveryTag = envelope.getDeliveryTag();
if (!consumer.endpoint.isAutoAck()) {
  log.trace("Acknowledging receipt [delivery_tag={}]", deliveryTag);
  channel.basicAck(deliveryTag, false);
}

So it's just expecting a synchronous processor. If you bind this to a seda route for instance, the process method returns immediately and you're pretty much back to the autoAck situation.

My understanding is that we need to make our own RabbitMQ component to do something like

consumer.getAsyncProcessor().process(exchange, new AsynCallback() {
  public void done(doneSync) {
    if (!consumer.endpoint.isAutoAck()) {
      long deliveryTag = envelope.getDeliveryTag();
      log.trace("Acknowledging receipt [delivery_tag={}]", deliveryTag);
      channel.basicAck(deliveryTag, false);
    }
  }
});

Even then, the semantics of the "doneSync" parameter is not clear to me. I think it's merely a marker to identify whether we're dealing with a real async processor or a synchronous processor that was automatically wrapped into an async one.

Maybe someone can validate or invalidate this solution?

Is there a lighter/faster/stronger alternative?

Or could this be suggested as the default implementation for the RabbitMQConsumer?