You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by ac...@apache.org on 2026/07/30 08:14:14 UTC

(camel) branch main updated: CAMEL-24286: Release the latch and unregister when a BackgroundTask supplier throws (#25217)

This is an automated email from the ASF dual-hosted git repository.

oscerd pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/main by this push:
     new ee9df19a53b6 CAMEL-24286: Release the latch and unregister when a BackgroundTask supplier throws (#25217)
ee9df19a53b6 is described below

commit ee9df19a53b6472ac08d077e7e23aa13c991754e
Author: Andrea Cosentino <an...@gmail.com>
AuthorDate: Thu Jul 30 10:14:07 2026 +0200

    CAMEL-24286: Release the latch and unregister when a BackgroundTask supplier throws (#25217)
    
    BackgroundTask.runTaskWrapper rethrew a supplier exception on the scheduler
    thread without counting down the completion latch or unregistering the task.
    doRun only catches TaskRunFailureException, so any other exception reached this
    path. scheduleWithFixedDelay then suppresses all further executions, and for a
    task built with withUnlimitedDuration() waitForTaskCompletion calls
    latch.await() with no timeout — so the calling thread blocked forever and the
    task leaked in the TaskManagerRegistry.
    
    This is reachable on main via CAMEL-24272: camel-ftp SFTP (tryConnect catches
    only JSchException) and camel-mongodb-gridfs (its Mongo cursor/find calls are
    outside the inner catch) both run an unlimited-duration reconnection through
    BackgroundTask.run().
    
    Fix: in the catch, mark the task not-completed, unregister it, and count down
    the latch before rethrowing, so the blocking run() caller unblocks and observes
    the failure. The rethrow is kept so the schedule() path still surfaces the
    error to the executor.
    
    Also move removeTask + task.cancel into the finally of waitForTaskCompletion,
    so an InterruptedException from latch.await() no longer leaves the task
    registered.
    
    Add a regression test that runs an unlimited-duration task whose supplier
    throws; it fails (run() hangs on the join) without the fix and passes with it.
    The runner is a daemon thread so a regression cannot wedge the JVM.
    
    Co-authored-by: Claude Opus 4.8 <no...@anthropic.com>
---
 .../task/task/BackgroundTaskRegistryTest.java      | 43 ++++++++++++++++++++++
 .../apache/camel/support/task/BackgroundTask.java  | 27 +++++++++-----
 2 files changed, 60 insertions(+), 10 deletions(-)

diff --git a/core/camel-core/src/test/java/org/apache/camel/support/task/task/BackgroundTaskRegistryTest.java b/core/camel-core/src/test/java/org/apache/camel/support/task/task/BackgroundTaskRegistryTest.java
index 3f0154d49802..011228af1275 100644
--- a/core/camel-core/src/test/java/org/apache/camel/support/task/task/BackgroundTaskRegistryTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/support/task/task/BackgroundTaskRegistryTest.java
@@ -128,6 +128,49 @@ class BackgroundTaskRegistryTest {
         assertThat(registry.getTasks()).isEmpty();
     }
 
+    @DisplayName("Test that run() returns and unregisters when the supplier throws (CAMEL-24286)")
+    @Test
+    @Timeout(15)
+    void testRunReturnsAndUnregistersWhenSupplierThrows() throws Exception {
+        AtomicBoolean runReturned = new AtomicBoolean(false);
+        AtomicBoolean completed = new AtomicBoolean(true);
+
+        // an unlimited-duration task: before CAMEL-24286 a thrown supplier exception left the latch
+        // un-counted, so run() blocked forever here and the task leaked in the registry
+        BackgroundTask task = Tasks.backgroundTask()
+                .withScheduledExecutor(Executors.newSingleThreadScheduledExecutor())
+                .withBudget(Budgets.iterationTimeBudget()
+                        .withInterval(Duration.ofMillis(100))
+                        .withInitialDelay(Duration.ZERO)
+                        .withUnlimitedDuration()
+                        .build())
+                .build();
+
+        // daemon so a regression (run() hanging forever) cannot keep the JVM alive
+        Thread runner = new Thread(() -> {
+            boolean result = task.run(camelContext, () -> {
+                throw new IllegalStateException("boom");
+            });
+            completed.set(result);
+            runReturned.set(true);
+        });
+        runner.setDaemon(true);
+        runner.start();
+
+        runner.join(TimeUnit.SECONDS.toMillis(10));
+
+        assertThat(runReturned.get())
+                .as("run() must return when the supplier throws, not block forever")
+                .isTrue();
+        assertThat(completed.get())
+                .as("run() should report the task as not completed after a thrown exception")
+                .isFalse();
+        await().atMost(2, TimeUnit.SECONDS)
+                .untilAsserted(() -> assertThat(registry.getTasks())
+                        .as("the failed task must not leak in the registry")
+                        .isEmpty());
+    }
+
     @DisplayName("Test that task is removed from registry after supplier succeeds")
     @Test
     @Timeout(10)
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/task/BackgroundTask.java b/core/camel-support/src/main/java/org/apache/camel/support/task/BackgroundTask.java
index 5065391ca38e..c8776c352898 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/task/BackgroundTask.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/task/BackgroundTask.java
@@ -130,7 +130,14 @@ public class BackgroundTask extends AbstractTask implements BlockingTask {
             }
         } catch (Exception e) {
             status = Status.Failed;
+            completed.set(false);
             cause = e;
+            // release the blocking run() caller and unregister; without this a task built with
+            // withUnlimitedDuration() would await() forever and stay in the registry (CAMEL-24286)
+            if (!registeredByRun && registry != null) {
+                registry.removeTask(this);
+            }
+            latch.countDown();
             throw e;
         }
         // scheduleWithFixedDelay waits interval after this run finishes, so compute from now
@@ -196,20 +203,20 @@ public class BackgroundTask extends AbstractTask implements BlockingTask {
                     LOG.debug("The task has finished the execution and it is ready to continue");
                 }
             }
-
-            TaskManagerRegistry registry = null;
-            if (camelContext != null) {
-                registry = PluginHelper.getTaskManagerRegistry(camelContext.getCamelContextExtension());
-            }
-            if (registry != null) {
-                registry.removeTask(this);
-            }
-
-            task.cancel(true);
         } catch (InterruptedException e) {
             LOG.warn("Interrupted while waiting for the repeatable task to execute: {}", e.getMessage(), e);
             Thread.currentThread().interrupt();
         } finally {
+            // unregister and cancel even if the await was interrupted, otherwise the task leaks in
+            // the registry and the scheduled future keeps running (CAMEL-24286)
+            if (camelContext != null) {
+                TaskManagerRegistry registry
+                        = PluginHelper.getTaskManagerRegistry(camelContext.getCamelContextExtension());
+                if (registry != null) {
+                    registry.removeTask(this);
+                }
+            }
+            task.cancel(true);
             elapsed = budget.elapsed();
             running.set(false);
         }