shashank created CAMEL-27047:
--------------------------------

             Summary: camel-core - UnitOfWorkProducer (injected producers and 
@Produce proxies): a producer that throws before it calls the callback leaves 
the exchange in the inflight repository
                 Key: CAMEL-27047
                 URL: https://issues.apache.org/jira/browse/CAMEL-27047
             Project: Camel
          Issue Type: Bug
          Components: camel-core
            Reporter: shashank
            Assignee: shashank


Found next to CAMEL-27039 (named there as a follow-up). Reproduced on main with 
a plain unit test (below).

h3. What happens

The producer injected with {{@EndpointInject}} / {{@Produce}} into a 
{{Producer}} field, and the producer of the {{@Produce}} proxies, is made by 
{{DefaultDeferServiceFactory}}: {{EventNotifierProducer}} around 
{{UnitOfWorkProducer}} around the producer of the endpoint. 
{{UnitOfWorkProducer}} calls the producer through a {{CamelInternalProcessor}} 
with the unit of work advice. The advice creates the unit of work, which adds 
the exchange to the inflight repository, and the unit of work is done (and the 
exchange removed) in the after advice, which runs from the callback. When the 
producer throws instead of calling the callback (an {{AsyncProducer}} that 
breaks the async contract), {{CamelInternalProcessor.processNonTransacted}} 
throws the exception on without running the after advice. 
{{EventNotifierProducer}} then sets the exception on the exchange and calls the 
callback of the caller, so the caller sees a failed exchange, but the unit of 
work is never done: the exchange stays in the inflight repository (and the 
synchronizations of the unit of work do not run, and no completed or failed 
event is fired). Each such send leaves one more entry in the inflight 
repository.

h3. Expected

The unit of work that {{UnitOfWorkProducer}} created is done exactly once on 
every path, as CAMEL-26953 made the sync send of the producer cache do 
({{DefaultProducerCache.SyncSend}}): a throw before the callback fails the 
exchange and completes the send.

h3. Reproduction

New {{UnitOfWorkProducerProducerThrowsTest}} (camel-core): an {{AsyncProducer}} 
that throws {{IllegalStateException}} without calling the callback.
* the producer that {{@EndpointInject}} injects 
({{PluginHelper.getDeferServiceFactory(context).createProducer(endpoint)}}), 
{{process(exchange)}}: the exchange has the exception, and on main 
{{context.getInflightRepository().size()}} is 1 afterwards.
* {{UnitOfWorkProducer}} directly: on main {{process(exchange, callback)}} 
throws, the callback is not called and the exchange stays inflight.
* the same with an {{AssertionError}} (CAMEL-26741: an {{Error}} that is not a 
{{VirtualMachineError}} fails the exchange).

h3. Fix

{{UnitOfWorkProducer}} calls the producer through a small wrapper with a 
callback per send (an {{AtomicBoolean}}, as {{DefaultProducerCache.SyncSend}}). 
A throw before the callback sets the exception on the exchange and calls the 
callback, so the after advice runs and the unit of work is done once. A throw 
after the callback is thrown on as before (the caller handles it, CAMEL-27039). 
A further call of the callback is logged at WARN and ignored, so the unit of 
work is not done twice. A {{VirtualMachineError}} is thrown on as before. 
Branch {{camel-core-event-notifier-producer-inflight-on-throw}}.

_Filed with Claude Code on behalf of allthingssecurity._



--
This message was sent by Atlassian Jira
(v10.3.26#10030026)

Reply via email to