[4.x] Scheduling fixes (#10837)

* Add isEnabled to scheduling tasks
* Vetoed CDI beans shouldn't be scheduled #9828
* Fix intermittent failure in executedEvery2Sec #10682

Signed-off-by: Daniel Kec <[email protected]>

Author: danielkec

microprofile/scheduling/src/main/java/io/helidon/microprofile/scheduling/SchedulingCdiExtension.java

@@ -112,6 +112,9 @@ void invoke(@Observes @Priority(PLATFORM_AFTER + 4000) @Initialized(ApplicationS
         for (AnnotatedMethod<?> am : methods) {
             Class<?> aClass = am.getDeclaringType().getJavaClass();
             Bean<?> bean = beans.get(am);
+            if (bean == null) {
+                continue;
+            }
             Object beanInstance = lookup(bean, beanManager);
             Method method = am.getJavaMember();
 

microprofile/scheduling/src/test/java/io/helidon/microprofile/scheduling/SchedulingTest.java

@@ -17,8 +17,11 @@
 package io.helidon.microprofile.scheduling;
 
 import java.time.Duration;
+import java.time.Instant;
 import java.time.LocalTime;
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
@@ -44,11 +47,14 @@
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.hamcrest.Matchers.lessThan;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
 @HelidonTest
 @DisableDiscovery
 @AddBean(SchedulingTest.ScheduledBean.class)
+@AddBean(SchedulingTest.ScheduledVetoMeBean.class)
 @AddExtension(SchedulingCdiExtension.class)
+@AddExtension(TestVetoingCdiExtension.class)
 @Configuration(configSources = "test.properties")
 public class SchedulingTest {
 
@@ -120,7 +126,13 @@ void expressionPlaceHolder() throws InterruptedException {
     void executedEvery2Sec() throws InterruptedException {
         assertThat("Scheduled method expected to be invoked at least twice",
                    scheduledBean.getCountDownLatch().await(5, TimeUnit.SECONDS));
-        assertDuration(TWO_SEC_MILLIS, scheduledBean.getDuration(), 2000);
+        assertDuration(TWO_SEC_MILLIS, scheduledBean.getDurations(), TWO_SEC_MILLIS);
+    }
+
+    @Test
+    void vetoedShouldNotBeInvoked() throws InterruptedException {
+        Thread.sleep(3000);
+        assertFalse(ScheduledVetoMeBean.triggered);
     }
 
     @Test
@@ -166,8 +178,9 @@ interval, is(Duration.ofSeconds(2)))
         );
     }
 
-    private void assertDuration(long expectedDuration, long duration, long allowedDiscrepancy) {
-        String durationString = "Expected duration is 2 sec, but was " + ((float) duration / 1000) + "sec";
+    private void assertDuration(long expectedDuration, List<Duration> durations, long allowedDiscrepancy) {
+        var duration = durations.getFirst().toMillis();
+        String durationString = "Expected duration is " + expectedDuration + " mls, but was " + duration + " mls";
         assertThat(durationString, duration, greaterThan(expectedDuration - allowedDiscrepancy));
         assertThat(durationString, duration, lessThan(expectedDuration + allowedDiscrepancy));
     }
@@ -179,6 +192,7 @@ public static class ScheduledBean {
 
         final CountDownLatch countDownLatch = new CountDownLatch(2);
 
+        private final List<Duration> durations = new CopyOnWriteArrayList<>();
 
         volatile long duration = 0;
         volatile long stamp = 0;
@@ -187,16 +201,33 @@ public CountDownLatch getCountDownLatch() {
             return countDownLatch;
         }
 
-        public long getDuration() {
-            return duration;
+        public List<Duration> getDurations() {
+            return durations;
         }
 
         @Scheduling.Cron("0/2 * * * * ? *")
         public void test2sec() {
-            duration = System.currentTimeMillis() - stamp;
+            if(stamp != 0) {
+                duration = System.currentTimeMillis() - stamp;
+                durations.add(Duration.ofMillis(duration));
+            }
             stamp = System.currentTimeMillis();
+            LOGGER.log(System.Logger.Level.DEBUG, () -> Thread.currentThread().getName() + " Executed at " + Instant.ofEpochMilli(stamp) + "(" + stamp);
             countDownLatch.countDown();
-            LOGGER.log(System.Logger.Level.DEBUG, () -> "Executed at " + LocalTime.now().toString());
+        }
+    }
+
+    @ApplicationScoped
+    public static class ScheduledVetoMeBean {
+
+        private static final System.Logger LOGGER = System.getLogger(ScheduledVetoMeBean.class.getName());
+
+        static volatile boolean triggered = false;
+
+        @Scheduling.Cron("0/1 * * * * ? *")
+        public void test1sec() {
+            triggered = true;
+            LOGGER.log(System.Logger.Level.DEBUG, () -> "Executed at " + LocalTime.now());
         }
     }
 }

microprofile/scheduling/src/test/java/io/helidon/microprofile/scheduling/TestVetoingCdiExtension.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.microprofile.scheduling;
+
+import jakarta.enterprise.event.Observes;
+import jakarta.enterprise.inject.spi.AnnotatedType;
+import jakarta.enterprise.inject.spi.Extension;
+import jakarta.enterprise.inject.spi.ProcessAnnotatedType;
+
+/**
+ * CDI Extension that vetoes any CDI bean whose class name contains "VetoMe".
+ */
+public class TestVetoingCdiExtension implements Extension {
+
+    void processAnnotatedType(@Observes ProcessAnnotatedType<?> pat) {
+        AnnotatedType<?> annotatedType = pat.getAnnotatedType();
+        Class<?> clazz = annotatedType.getJavaClass();
+
+        if (clazz.getSimpleName().contains("VetoMe")) {
+            pat.veto();
+        }
+    }
+}

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

@@ -142,6 +142,11 @@ public void close() {
         }
     }
 
+    @Override
+    public boolean enabled() {
+        return config.enabled();
+    }
+
     @Override
     public String id() {
         return taskId;

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

@@ -93,6 +93,11 @@ public void close() {
         config.taskManager().remove(this);
     }
 
+    @Override
+    public boolean enabled() {
+        return config.enabled();
+    }
+
     @Override
     public String id() {
         return taskId;

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

@@ -42,6 +42,16 @@ public interface Task {
     default void close() {
     }
 
+    /**
+     * If task is enabled or disabled, scheduling tasks are enabled by default
+     * and can be disabled programmatically or via configuration.
+     *
+     * @return true if enabled
+     */
+    default boolean enabled() {
+        return true;
+    }
+
     /**
      * ID used to identify this task.
      * It should be unique, as it is used to identify a single task, for example to cancel it.

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

@@ -36,12 +36,13 @@
 
 import static org.hamcrest.CoreMatchers.hasItem;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
 
 @SuppressWarnings("removal")
 @Testing.Test
 @Execution(ExecutionMode.CONCURRENT)
-public class CronSchedulingTest {
+class CronSchedulingTest {
 
     static final long ERROR_MARGIN_MILLIS = 500;
 
@@ -309,24 +310,25 @@ void cronMissingTask() {
     void cronDisabledProgrammatically() throws InterruptedException {
         ScheduledExecutorService executorService = ScheduledThreadPoolSupplier.create().get();
         IntervalMeter meter = new IntervalMeter();
-        Cron cron = null;
+        Cron task = null;
 
         try {
-            cron = Cron.builder()
+            task = Cron.builder()
                     .id("disabledCronTest")
                     .executor(executorService)
                     .expression("* * * * * ? *")  // Every second
                     .enabled(false)  // Disabled
                     .task(cronInvocation -> meter.start().end())
                     .build();
 
-            // Wait and verify task never executed
+            // Wait and verify the task never executed
             Thread.sleep(3000);
             assertThat(meter.size(), Matchers.equalTo(0));
-            assertThat(taskManager.tasks(), hasItem(cron));
+            assertThat(taskManager.tasks(), hasItem(task));
+            assertThat(task.enabled(), is(false));
         } finally {
-            if (cron != null) {
-                cron.close();
+            if (task != null) {
+                task.close();
             }
             executorService.shutdownNow();
         }

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

@@ -32,16 +32,24 @@
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
 
+import static org.hamcrest.CoreMatchers.hasItem;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @Testing.Test
 @Execution(ExecutionMode.CONCURRENT)
-public class FixedRateSchedulingTest {
+class FixedRateSchedulingTest {
 
     static final long ERROR_MARGIN_MILLIS = 500;
 
+    private final TaskManager taskManager;
+
+    FixedRateSchedulingTest(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
     @SuppressWarnings("removal")
     @Test
     void fixedRateDelayDeprecated() {
@@ -314,16 +322,18 @@ void fixedRateDisabled() throws InterruptedException {
         IntervalMeter meter = new IntervalMeter();
 
         try {
-            FixedRate.builder()
+            var task = FixedRate.builder()
                     .executor(executorService)
                     .interval(Duration.ofSeconds(1))
                     .enabled(false)  // Disabled
                     .task(inv -> meter.start().end())
                     .build();
 
-            // Wait and verify task never executed
+            // Wait and verify the task never executed
             Thread.sleep(3000);
-            assertThat(meter.size(), Matchers.equalTo(0));
+            assertThat(meter.size(), equalTo(0));
+            assertThat(taskManager.tasks(), hasItem(task));
+            assertThat(task.enabled(), equalTo(false));
         } finally {
             executorService.shutdownNow();
         }