shashank created CAMEL-27089:
--------------------------------
Summary: camel-core - parallel Multicast, Split and Recipient
List: an exchange waiting for a part when its route is removed after a forced
stop is never completed, and its caller waits for ever
Key: CAMEL-27089
URL: https://issues.apache.org/jira/browse/CAMEL-27089
Project: Camel
Issue Type: Bug
Components: camel-core
Reporter: shashank
Assignee: shashank
h3. What happens
A parallel Multicast, Split or Recipient List submits its task, and then one
task per part, to its thread pool; the last part to be aggregated calls the
callback. When the route is removed, {{MulticastProcessor.doShutdown}} (and
{{RecipientList.doShutdown}}) shut that pool down with {{shutdownNow}}: the
parts still queued are dropped and the exchange waits for them for ever.
This happens when a route is stopped with a timeout that runs out (the default
graceful timeout, or {{stopRoute(id, timeout, unit)}}) and then removed, which
is also what a route reload does, while an exchange still waits for a part (a
slow part on a busy pool). A synchronous caller ({{ProducerTemplate}} request,
{{direct}} caller) then waits for ever, and the exchange stays in the in-flight
registry with its unit of work never done.
Found with a TLA+ model of the protocol (the task and two parts on the pool,
route stop with graceful wait or timeout, removal with shutdownNow, running
parts that end after it). On main, "once the route is removed and nothing is
left to run, the exchange was completed" is violated with the trace: send,
stop, timeout, remove. Failing the tasks at shutdown without the task's done
flag breaks "the callback is called at most once".
h3. How to reproduce
{code:java}
context.getExecutorServiceManager()
.registerThreadPoolProfile(new
ThreadPoolProfileBuilder("one").poolSize(1).maxPoolSize(1).build());
from("direct:block").process(e -> latch.await(20, TimeUnit.SECONDS));
from("direct:start").routeId("parallel")
.multicast().parallelProcessing().executorService("one").to("direct:block",
"mock:b");
CompletableFuture<Exchange> f = template.asyncSend("direct:start", e -> {});
// wait until the first part blocks; the second part is queued in the pool
context.getRouteController().stopRoute("parallel", 100, TimeUnit.MILLISECONDS);
context.removeRoute("parallel");
f.get(10, TimeUnit.SECONDS); // TimeoutException
{code}
The same with {{split(body()).parallelProcessing()}} and
{{recipientList(body()).parallelProcessing()}}.
h3. Fix
The processor keeps its parallel tasks that are not done; after shutting down
its own thread pool, doShutdown fails each of them with a
RouteStoppingException through doFailed, which uses the same done flag as the
other ways a task completes, so the callback is called once. A user-supplied
pool that the EIP does not shut down is not affected.
_Filed with Claude Code on behalf of allthingssecurity._
--
This message was sent by Atlassian Jira
(v10.3.26#10030026)