made the interfaces simpler

Author: sterlp

core/src/main/java/org/sterl/spring/persistent_tasks/api/event/TriggerTaskCommand.java

@@ -24,6 +24,14 @@ public static <T extends Serializable> TriggerTaskCommand<T> of(String name, T s
                 .state(state)
                 .build()));
     }
+    
+    public static <T extends Serializable> TriggerTaskCommand<T> of(String name, T state, String correlationId) {
+        return new TriggerTaskCommand<>(Collections.singleton(TriggerBuilder
+                .<T>newTrigger(name)
+                .state(state)
+                .correlationId(correlationId)
+                .build()));
+    }
 
     public static <T extends Serializable> TriggerTaskCommand<T> of(Collection<AddTriggerRequest<T>> triggers) {
         return new TriggerTaskCommand<>(triggers);

core/src/main/java/org/sterl/spring/persistent_tasks/api/task/ComplexPersistentTask.java

@@ -3,6 +3,7 @@
 import java.io.Serializable;
 
 import org.springframework.lang.Nullable;
+import org.sterl.spring.persistent_tasks.api.RetryStrategy;
 import org.sterl.spring.persistent_tasks.api.Trigger;
 
 /**
@@ -14,6 +15,40 @@
  * @param <T> the type of the state, which must be {@link Serializable}
  */
 @FunctionalInterface
-public interface PersistentTask<T extends Serializable> extends PersistentTaskBase<T> {
+public interface PersistentTask<T extends Serializable> {
+
+    /**
+     * Called during the task execution with the stored state.
+     * <ul>
+     *  <li>
+     *  {@link RunningTriggerContextHolder} can be used to access the full state.
+     *  </li>
+     *  <li>
+     *  Fire {@link org.sterl.spring.persistent_tasks.api.event.TriggerTaskCommand} events to schedule new tasks.
+     *  </li>
+     *  <li>
+     *  Consider to use a {@link TransactionalTask} in case the triggers or the state should be written together in one transaction.
+     *  </li>
+     * </ul>
+     * @param state the state of this trigger, can be <code>null</code>
+     */
     void accept(@Nullable T state);
+
+    default RetryStrategy retryStrategy() {
+        return RetryStrategy.THREE_RETRIES;
+    }
+
+    /**
+     * Whether the persistentTask is transaction or not. If <code>true</code> the execution
+     * is wrapped into the default transaction template together with the state update
+     * and the following events:
+     * <ol>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent</li>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerSuccessEvent</li>
+     * </ol>
+     * @return {@code true} if the persistentTask is transactional; {@code false} otherwise.
+     */
+    default boolean isTransactional() {
+        return false;
+    }
 }

core/src/main/java/org/sterl/spring/persistent_tasks/api/task/ComplexTransactionalTask.java

@@ -1,11 +1,9 @@
-package org.sterl.spring.persistent_tasks.trigger;
+package org.sterl.spring.persistent_tasks.api.task;
 
 import java.io.Serializable;
 import java.util.Objects;
 import java.util.UUID;
 
-import org.sterl.spring.persistent_tasks.api.task.RunningTrigger;
-
 /**
  * The {@link RunningTrigger} state will be provided by this context holder to any thread.
  * Furthermore the correlationId of this context is preferred if a context is found.

core/src/main/java/org/sterl/spring/persistent_tasks/api/task/PersistentTask.java

@@ -143,6 +143,7 @@ public <T extends Serializable> TriggerKey runOrQueue(AddTriggerRequest<T> trigg
                 trigger = triggerService.markTriggersAsRunning(trigger, name);
                 pingRegistry().addRunning(1);
                 shouldRun.put(trigger.getId(), trigger);
+                log.debug("{} added for immediate execution, waitng for commit on={}", trigger.getKey(), name);
             } else {
                 log.debug("Currently not enough free thread available {} of {} in use. PersistentTask {} queued.",
                         taskExecutor.getFreeThreads(), taskExecutor.getMaxThreads(), trigger.getKey());
@@ -156,8 +157,8 @@ public <T extends Serializable> TriggerKey runOrQueue(AddTriggerRequest<T> trigg
     void checkIfTrigerIsRunning(TriggerAddedEvent addedTrigger) {
         final var toRun = shouldRun.remove(addedTrigger.id());
         if (toRun != null) {
-            log.debug("New triger added for imidiate execution {}", addedTrigger.key());
             taskExecutor.submit(toRun);
+            log.debug("{} immediately started on={}.", addedTrigger.key(), name);
         }
         // TODO implement a cleanup for old pending triggers which may never been triggered!
     }

core/src/main/java/org/sterl/spring/persistent_tasks/api/task/PersistentTaskBase.java

@@ -6,12 +6,11 @@
 import java.util.function.Consumer;
 
 import org.springframework.lang.NonNull;
+import org.springframework.lang.Nullable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.support.TransactionTemplate;
 import org.sterl.spring.persistent_tasks.api.TaskId;
-import org.sterl.spring.persistent_tasks.api.task.ComplexPersistentTask;
 import org.sterl.spring.persistent_tasks.api.task.PersistentTask;
-import org.sterl.spring.persistent_tasks.api.task.PersistentTaskBase;
 import org.sterl.spring.persistent_tasks.task.component.TaskTransactionComponent;
 import org.sterl.spring.persistent_tasks.task.repository.TaskRepository;
 
@@ -28,78 +27,67 @@ public Set<TaskId<? extends Serializable>> findAllTaskIds() {
         return this.taskRepository.all();
     }
 
-    public <T extends Serializable> Optional<PersistentTaskBase<T>> get(TaskId<T> id) {
+    public <T extends Serializable> Optional<PersistentTask<T>> get(TaskId<T> id) {
         return taskRepository.get(id);
     }
 
     public <T extends Serializable> Optional<TransactionTemplate> getTransactionTemplate(
-            PersistentTaskBase<T> task) {
+            PersistentTask<T> task) {
         return taskTransactionComponent.getTransactionTemplate(task);
     }
 
     /**
-     * Check if the {@link PersistentTaskBase} is known or not.
+     * Check if the {@link PersistentTask} is known or not.
      *
      * @param <T> the state type
-     * @param id the {@link TaskId} of the {@link PersistentTaskBase}
+     * @param id the {@link TaskId} of the {@link PersistentTask}
      * @throws IllegalStateException if the id is unknown
-     * @return the {@link PersistentTaskBase} registered to the given id
+     * @return the {@link PersistentTask} registered to the given id
      */
     @NonNull
-    public <T extends Serializable> PersistentTaskBase<T> assertIsKnown(@NonNull TaskId<T> id) {
+    public <T extends Serializable> PersistentTask<T> assertIsKnown(@NonNull TaskId<T> id) {
         final var task = taskRepository.get(id);
         if (task.isEmpty()) {
-            throw new IllegalStateException("PersistentTaskBase with ID " + id
+            throw new IllegalStateException("PersistentTask with ID " + id
                     + " is unknown. Known tasks: " + taskRepository.all());
         }
         return task.get();
     }
 
     /**
-     * A way to manually register a PersistentTaskBase, usually better to use {@link PersistentTaskBase}.
+     * A way to manually register a PersistentTask, usually better to use {@link PersistentTask}.
      */
     public TaskId<Serializable> register(String name, Consumer<Serializable> task) {
         return register(name, new PersistentTask<Serializable>() {
+            private static final long serialVersionUID = 1L;
             @Override
-            public void accept(Serializable state) {
+            public void accept(@Nullable Serializable state) {
                 task.accept(state);
             }
         });
     }
     /**
-     * A way to manually register a PersistentTaskBase, usually not needed as spring beans will be added automatically.
+     * A way to manually register a PersistentTask, usually not needed as spring beans will be added automatically.
      */
     @SuppressWarnings("unchecked")
-    public <T extends Serializable> TaskId<T> register(String name, PersistentTaskBase<T> task) {
+    public <T extends Serializable> TaskId<T> register(String name, PersistentTask<T> task) {
         var id = (TaskId<T>)TaskId.of(name);
         return register(id, task);
     }
     /**
-     * A way to manually register a PersistentTaskBase, usually not needed as spring beans will be added automatically.
+     * A way to manually register a PersistentTask, usually not needed as spring beans will be added automatically.
      */
-    public <T extends Serializable> TaskId<T> register(TaskId<T> id, PersistentTaskBase<T> task) {
-        // init any transaction as needed
+    public <T extends Serializable> TaskId<T> register(TaskId<T> id, PersistentTask<T> task) {
         taskTransactionComponent.getTransactionTemplate(task);
         return taskRepository.addTask(id, task);
     }
     /**
-     * A way to manually register a PersistentTaskBase, usually not needed as spring beans will be added automatically.
+     * A way to manually register a PersistentTask, usually not needed as spring beans will be added automatically.
      */
     @SuppressWarnings("unchecked")
     public <T extends Serializable> TaskId<T> replace(String name, PersistentTask<T> task) {
         var id = (TaskId<T>)TaskId.of(name);
         taskRepository.remove(id);
         return register(id, task);
     }
-    
-    /**
-     * A way to manually register a PersistentTaskBase, usually not needed as spring beans will be added automatically.
-     */
-    @SuppressWarnings("unchecked")
-    public <T extends Serializable, R extends Serializable> TaskId<T> replaceComplex(String name, 
-            ComplexPersistentTask<T, R> task) {
-        var id = (TaskId<T>)TaskId.of(name);
-        taskRepository.remove(id);
-        return register(id, task);
-    }
 }

core/src/main/java/org/sterl/spring/persistent_tasks/trigger/RunningTriggerContextHolder.java renamed to core/src/main/java/org/sterl/spring/persistent_tasks/api/task/RunningTriggerContextHolder.java

@@ -13,7 +13,7 @@
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.support.DefaultTransactionDefinition;
 import org.springframework.transaction.support.TransactionTemplate;
-import org.sterl.spring.persistent_tasks.api.task.PersistentTaskBase;
+import org.sterl.spring.persistent_tasks.api.task.PersistentTask;
 import org.sterl.spring.persistent_tasks.task.util.ReflectionUtil;
 
 import lombok.RequiredArgsConstructor;
@@ -28,9 +28,9 @@ public class TaskTransactionComponent {
     private final TransactionTemplate template;
     private final Set<Propagation> joinTransaction = EnumSet.of(
             Propagation.MANDATORY, Propagation.REQUIRED, Propagation.SUPPORTS);
-    private final Map<PersistentTaskBase<? extends Serializable>, Optional<TransactionTemplate>> cache = new ConcurrentHashMap<>();
+    private final Map<PersistentTask<? extends Serializable>, Optional<TransactionTemplate>> cache = new ConcurrentHashMap<>();
 
-    public Optional<TransactionTemplate> getTransactionTemplate(PersistentTaskBase<? extends Serializable> task) {
+    public Optional<TransactionTemplate> getTransactionTemplate(PersistentTask<? extends Serializable> task) {
         if (cache.containsKey(task)) return cache.get(task);
 
         Optional<TransactionTemplate> result;
@@ -47,7 +47,7 @@ public Optional<TransactionTemplate> getTransactionTemplate(PersistentTaskBase<?
         return result;
     }
 
-    private TransactionTemplate builTransactionTemplate(PersistentTaskBase<? extends Serializable> task, Transactional annotation) {
+    private TransactionTemplate builTransactionTemplate(PersistentTask<? extends Serializable> task, Transactional annotation) {
         TransactionTemplate result;
         if (joinTransaction.contains(annotation.propagation())) {
             // No direct mapping for 'rollbackFor' or 'noRollbackFor'

core/src/main/java/org/sterl/spring/persistent_tasks/scheduler/SchedulerService.java

@@ -7,7 +7,7 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.support.GenericApplicationContext;
 import org.sterl.spring.persistent_tasks.api.TaskId;
-import org.sterl.spring.persistent_tasks.api.task.PersistentTaskBase;
+import org.sterl.spring.persistent_tasks.api.task.PersistentTask;
 import org.sterl.spring.persistent_tasks.task.TaskService;
 
 import lombok.extern.slf4j.Slf4j;
@@ -19,8 +19,8 @@ public class TaskConfig {
     @Autowired
     void configureSimpleTasks(GenericApplicationContext context,
             TaskService taskService) {
-        final var simpleTasks = context.getBeansOfType(PersistentTaskBase.class);
-        for(Entry<String, PersistentTaskBase> t : simpleTasks.entrySet()) {
+        final var simpleTasks = context.getBeansOfType(PersistentTask.class);
+        for(Entry<String, PersistentTask> t : simpleTasks.entrySet()) {
             var id = taskService.register(t.getKey(), t.getValue());
 
             addTaskIdIfMissing(context, id);