Merge pull request #38021 from mkouba/issue-37805

Scheduler: Quartz - support JobDefinition API if DB type store is used

Author: gsmet

docs/src/main/asciidoc/scheduler-reference.adoc

@@ -406,7 +406,7 @@ class MyJobs {
 
 NOTE: By default, the scheduler is not started unless a `@Scheduled` business method is found. You may need to force the start of the scheduler for "pure" programmatic scheduling via `quarkus.scheduler.start-mode=forced`.
 
-NOTE: If the xref:quartz.adoc[Quartz extension] is present then only the RAM store type is supported, i.e. `quarkus.quartz.store-type=ram` must be set. The Quartz API can be also used to schedule a job programmatically.
+NOTE: If the xref:quartz.adoc[Quartz extension] is present and the DB store type is used then it's not possible to pass a task instance to the job definition and a task class must be used instead. The Quartz API can be also used to schedule a job programmatically.
 
 == Scheduled Methods and Testing
 

extensions/quartz/deployment/src/test/java/io/quarkus/quartz/test/programmatic/ProgrammaticJobsTest.java

@@ -8,17 +8,24 @@
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+import java.util.function.Function;
 
 import jakarta.enterprise.context.RequestScoped;
 import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 import io.quarkus.arc.Arc;
+import io.quarkus.arc.Unremovable;
 import io.quarkus.scheduler.Scheduled;
+import io.quarkus.scheduler.ScheduledExecution;
 import io.quarkus.scheduler.Scheduler;
 import io.quarkus.scheduler.Scheduler.JobDefinition;
+import io.quarkus.scheduler.Trigger;
 import io.quarkus.test.QuarkusUnitTest;
 import io.smallrye.common.vertx.VertxContext;
 import io.smallrye.mutiny.Uni;
@@ -38,10 +45,24 @@ public class ProgrammaticJobsTest {
     MyService myService;
 
     static final CountDownLatch SYNC_LATCH = new CountDownLatch(1);
+    static final CountDownLatch SYNC_CLASS_LATCH = new CountDownLatch(1);
     static final CountDownLatch ASYNC_LATCH = new CountDownLatch(1);
+    static final AtomicInteger SKIPPED_EXECUTIONS = new AtomicInteger();
+    static final CountDownLatch ASYNC_CLASS_LATCH = new CountDownLatch(1);
 
     @Test
     public void testJobs() throws InterruptedException {
+        scheduler.newJob("alwaysSkip1")
+                .setInterval("1s")
+                .setSkipPredicate(ex -> true)
+                .setTask(ex -> SKIPPED_EXECUTIONS.incrementAndGet())
+                .schedule();
+        scheduler.newJob("alwaysSkip2")
+                .setInterval("1s")
+                .setTask(ex -> SKIPPED_EXECUTIONS.incrementAndGet())
+                .setSkipPredicate(AlwaysSkipPredicate.class)
+                .schedule();
+
         Scheduler.JobDefinition job1 = scheduler.newJob("foo")
                 .setInterval("1s")
                 .setTask(ec -> {
@@ -58,7 +79,8 @@ public void testJobs() throws InterruptedException {
         job2.setTask(ec -> {
         });
 
-        job1.schedule();
+        Trigger trigger1 = job1.schedule();
+        assertNotNull(trigger1);
         assertTrue(ProgrammaticJobsTest.SYNC_LATCH.await(5, TimeUnit.SECONDS));
 
         assertEquals("Cannot modify a job that was already scheduled",
@@ -79,6 +101,10 @@ public void testJobs() throws InterruptedException {
         assertNull(scheduler.unscheduleJob("nonexisting"));
 
         assertNotNull(scheduler.unscheduleJob("foo"));
+        assertNotNull(scheduler.unscheduleJob("alwaysSkip1"));
+        assertNotNull(scheduler.unscheduleJob("alwaysSkip2"));
+        assertEquals(0, SKIPPED_EXECUTIONS.get());
+        // Jobs#dummy()
         assertEquals(1, scheduler.getScheduledJobs().size());
     }
 
@@ -97,12 +123,33 @@ public void testAsyncJob() throws InterruptedException {
                 assertThrows(IllegalStateException.class, () -> asyncJob.setTask(ec -> {
                 })).getMessage());
 
-        asyncJob.schedule();
+        Trigger trigger = asyncJob.schedule();
+        assertNotNull(trigger);
 
         assertTrue(ProgrammaticJobsTest.ASYNC_LATCH.await(5, TimeUnit.SECONDS));
         assertNotNull(scheduler.unscheduleJob("fooAsync"));
     }
 
+    @Test
+    public void testClassJobs() throws InterruptedException {
+        scheduler.newJob("fooClass")
+                .setInterval("1s")
+                .setTask(JobClassTask.class)
+                .schedule();
+        assertTrue(ProgrammaticJobsTest.SYNC_CLASS_LATCH.await(5, TimeUnit.SECONDS));
+        assertNotNull(scheduler.unscheduleJob("fooClass"));
+    }
+
+    @Test
+    public void testClassAsyncJobs() throws InterruptedException {
+        scheduler.newJob("fooAsyncClass")
+                .setInterval("1s")
+                .setAsyncTask(JobClassAsyncTask.class)
+                .schedule();
+        assertTrue(ProgrammaticJobsTest.ASYNC_CLASS_LATCH.await(5, TimeUnit.SECONDS));
+        assertNotNull(scheduler.unscheduleJob("fooAsyncClass"));
+    }
+
     static class Jobs {
 
         @Scheduled(identity = "bar", every = "60m")
@@ -119,4 +166,45 @@ void countDown(CountDownLatch latch) {
 
     }
 
+    public static class AlwaysSkipPredicate implements Scheduled.SkipPredicate {
+
+        @Override
+        public boolean test(ScheduledExecution execution) {
+            return true;
+
+        }
+    }
+
+    @Unremovable
+    @Singleton
+    public static class JobClassTask implements Consumer<ScheduledExecution> {
+
+        @Inject
+        MyService myService;
+
+        @Override
+        public void accept(ScheduledExecution se) {
+            assertTrue(Arc.container().requestContext().isActive());
+            myService.countDown(SYNC_CLASS_LATCH);
+        }
+
+    }
+
+    @Unremovable
+    @Singleton
+    public static class JobClassAsyncTask implements Function<ScheduledExecution, Uni<Void>> {
+
+        @Inject
+        MyService myService;
+
+        @Override
+        public Uni<Void> apply(ScheduledExecution se) {
+            assertTrue(Context.isOnEventLoopThread() && VertxContext.isOnDuplicatedContext());
+            assertTrue(Arc.container().requestContext().isActive());
+            myService.countDown(ASYNC_CLASS_LATCH);
+            return Uni.createFrom().voidItem();
+        }
+
+    }
+
 }