Add configurable enabled flag for scheduling tasks (helidon-io#10812) (helidon-io#10825)

* Add configurable enabled flag for scheduling tasks (helidon-io#10812)

Adds support for disabling scheduled tasks via configuration,
similar to Spring's @scheduled(enabled = false).

Changes:
- Add 'enabled' property to TaskConfigBlueprint (default: true)
- Update CronTask to check enabled flag before scheduling
- Update FixedRateTask to check enabled flag before scheduling
- Create cancelled dummy future for disabled tasks to maintain
  compatibility with existing close() logic
- Add tests for disabled Cron and FixedRate tasks

Usage:
  Cron.builder()
      .expression("0 45 9 ? * *")
      .enabled(false)
      .build();

Or via configuration:
  my-task:
    enabled: false
    expression: "0 45 9 ? * *"

* Simplify disabled task handling in scheduling

Replace unnecessary scheduling and cancellation with CompletableFuture.completedFuture(null) for disabled tasks. Update future type from ScheduledFuture to Future for better flexibility. Ensure task manager cleanup always occurs in close() method.

Based on the code review suggestion

Author: vikky49

scheduling/src/main/java/io/helidon/scheduling/CronTask.java

@@ -22,8 +22,9 @@
 import java.util.Locale;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.ReentrantLock;
@@ -53,7 +54,7 @@ class CronTask implements Cron {
     private ZonedDateTime lastNext = null;
 
     private volatile boolean stopped;
-    private volatile ScheduledFuture<?> future;
+    private volatile Future<?> future;
 
     CronTask(CronConfig config) {
         this.config = config;
@@ -68,7 +69,13 @@ class CronTask implements Cron {
         executionTime = ExecutionTime.forCron(cron);
 
         config.taskManager().register(this);
-        scheduleNext();
+
+        if (config.enabled()) {
+            scheduleNext();
+        } else {
+            future = CompletableFuture.completedFuture(null);
+            LOGGER.log(Level.INFO, "Task " + taskId + " is disabled and will not be scheduled");
+        }
     }
 
     @Override
@@ -128,8 +135,8 @@ public void close() {
             stopped = true;
             if (future != null) {
                 future.cancel(false);
-                config.taskManager().remove(this);
             }
+            config.taskManager().remove(this);
         } finally {
             scheduleNextLock.unlock();
         }

scheduling/src/main/java/io/helidon/scheduling/FixedRateTask.java

@@ -19,8 +19,9 @@
 import java.lang.System.Logger.Level;
 import java.time.Duration;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 
@@ -33,7 +34,7 @@ class FixedRateTask implements FixedRate {
     private final Duration initialDelay;
     private final Duration interval;
     private final ScheduledConsumer<FixedRateInvocation> actualTask;
-    private final ScheduledFuture<?> future;
+    private final Future<?> future;
     private final FixedRateConfig config;
     private final String taskId;
 
@@ -46,16 +47,21 @@ class FixedRateTask implements FixedRate {
         this.executorService = config.executor();
         this.taskId = config.id().orElseGet(() -> UUID.randomUUID().toString());
 
-        this.future = switch (config.delayType()) {
-            case SINCE_PREVIOUS_START -> executorService.scheduleAtFixedRate(this::run,
-                                                                             initialDelay.toMillis(),
-                                                                             interval.toMillis(),
-                                                                             TimeUnit.MILLISECONDS);
-            case SINCE_PREVIOUS_END -> executorService.scheduleWithFixedDelay(this::run,
-                                                                              initialDelay.toMillis(),
-                                                                              interval.toMillis(),
-                                                                              TimeUnit.MILLISECONDS);
-        };
+        if (config.enabled()) {
+            this.future = switch (config.delayType()) {
+                case SINCE_PREVIOUS_START -> executorService.scheduleAtFixedRate(this::run,
+                                                                                 initialDelay.toMillis(),
+                                                                                 interval.toMillis(),
+                                                                                 TimeUnit.MILLISECONDS);
+                case SINCE_PREVIOUS_END -> executorService.scheduleWithFixedDelay(this::run,
+                                                                                  initialDelay.toMillis(),
+                                                                                  interval.toMillis(),
+                                                                                  TimeUnit.MILLISECONDS);
+            };
+        } else {
+            this.future = CompletableFuture.completedFuture(null);
+            LOGGER.log(Level.INFO, "Task " + taskId + " is disabled and will not be scheduled");
+        }
 
         config.taskManager().register(this);
     }
@@ -81,7 +87,9 @@ public ScheduledExecutorService executor() {
 
     @Override
     public void close() {
-        future.cancel(false);
+        if (future != null) {
+            future.cancel(false);
+        }
         config.taskManager().remove(this);
     }
 

scheduling/src/main/java/io/helidon/scheduling/TaskConfigBlueprint.java

@@ -48,4 +48,14 @@ interface TaskConfigBlueprint {
      */
     @Option.Configured
     Optional<String> id();
+
+    /**
+     * Whether the task is enabled. If disabled, the task will not be scheduled.
+     * Default value is {@code true}.
+     *
+     * @return true if the task should be scheduled
+     */
+    @Option.Configured
+    @Option.DefaultBoolean(true)
+    boolean enabled();
 }

scheduling/src/test/java/io/helidon/scheduling/CronSchedulingTest.java

@@ -305,4 +305,31 @@ void cronMissingTask() {
         }
     }
 
+    @Test
+    void cronDisabledProgrammatically() throws InterruptedException {
+        ScheduledExecutorService executorService = ScheduledThreadPoolSupplier.create().get();
+        IntervalMeter meter = new IntervalMeter();
+        Cron cron = null;
+
+        try {
+            cron = Cron.builder()
+                    .id("disabledCronTest")
+                    .executor(executorService)
+                    .expression("* * * * * ? *")  // Every second
+                    .enabled(false)  // Disabled
+                    .task(cronInvocation -> meter.start().end())
+                    .build();
+
+            // Wait and verify task never executed
+            Thread.sleep(3000);
+            assertThat(meter.size(), Matchers.equalTo(0));
+            assertThat(taskManager.tasks(), hasItem(cron));
+        } finally {
+            if (cron != null) {
+                cron.close();
+            }
+            executorService.shutdownNow();
+        }
+    }
+
 }

scheduling/src/test/java/io/helidon/scheduling/FixedRateSchedulingTest.java

@@ -307,4 +307,25 @@ void fixedRateMissingTask() {
             executorService.shutdownNow();
         }
     }
+
+    @Test
+    void fixedRateDisabled() throws InterruptedException {
+        ScheduledExecutorService executorService = ScheduledThreadPoolSupplier.create().get();
+        IntervalMeter meter = new IntervalMeter();
+
+        try {
+            FixedRate.builder()
+                    .executor(executorService)
+                    .interval(Duration.ofSeconds(1))
+                    .enabled(false)  // Disabled
+                    .task(inv -> meter.start().end())
+                    .build();
+
+            // Wait and verify task never executed
+            Thread.sleep(3000);
+            assertThat(meter.size(), Matchers.equalTo(0));
+        } finally {
+            executorService.shutdownNow();
+        }
+    }
 }