refactor(TriggerContext): refactor TriggerContext and update TriggerCondition#reasonCode

Author: zero88

core/src/main/java/io/github/zero88/schedulerx/JobData.java

@@ -12,7 +12,6 @@
  * @param <T> Type of data
  * @since 1.0.0
  */
-@FunctionalInterface
 public interface JobData<T> {
 
     /**

core/src/main/java/io/github/zero88/schedulerx/JobExecutor.java

@@ -10,6 +10,7 @@
  * @since 1.0.0
  */
 @Internal
+@FunctionalInterface
 public interface JobExecutor<OUT> {
 
     /**

core/src/main/java/io/github/zero88/schedulerx/JobExecutorContext.java

@@ -4,7 +4,7 @@
 import org.jetbrains.annotations.NotNull;
 
 /**
- * Shared immutable fields between JobExecutor and its builder.
+ * Shared immutable fields between {@code JobExecutor} and its builder.
  * <p/>
  * This class is designed to internal usage, don't refer it in your code.
  *

core/src/main/java/io/github/zero88/schedulerx/SchedulerContext.java

@@ -6,6 +6,15 @@
 import io.github.zero88.schedulerx.trigger.Trigger;
 import io.vertx.core.Vertx;
 
+/**
+ * Shared immutable fields between {@code Scheduler} and its builder.
+ * <p/>
+ * This class is designed to internal usage, don't refer it in your code.
+ *
+ * @param <TRIGGER> Type of trigger
+ * @param <OUT>     Type of job result data
+ * @since 2.0.0
+ */
 @Internal
 interface SchedulerContext<TRIGGER extends Trigger, OUT> {
 

core/src/main/java/io/github/zero88/schedulerx/impl/AbstractScheduler.java

@@ -65,12 +65,12 @@ public abstract class AbstractScheduler<IN, OUT, T extends Trigger> implements S
     protected AbstractScheduler(@NotNull Vertx vertx, @NotNull SchedulingMonitor<OUT> monitor,
                                 @NotNull JobData<IN> jobData, @NotNull Job<IN, OUT> job, @NotNull T trigger,
                                 @NotNull TimeoutPolicy timeoutPolicy) {
+        this.job           = job;
+        this.jobData       = jobData;
+        this.timeoutPolicy = timeoutPolicy;
         this.vertx         = vertx;
         this.trigger       = trigger;
         this.monitor       = monitor;
-        this.jobData       = jobData;
-        this.job           = job;
-        this.timeoutPolicy = timeoutPolicy;
         this.state         = new SchedulerStateImpl<>();
     }
 
@@ -147,7 +147,7 @@ public final void executeJob(@NotNull ExecutionContext<OUT> executionContext) {
     public final void cancel() {
         if (!state.completed()) {
             log(Instant.now(), "On cancel");
-            doStop(state.timerId(), TriggerContextFactory.stop(trigger().type(), ReasonCode.STOP_BY_MANUAL));
+            doStop(state.timerId(), TriggerContextFactory.cancel(trigger().type(), state.tick()));
         }
     }
 
@@ -173,7 +173,7 @@ protected final void doStop(long timerId, TriggerContext context) {
     /**
      * Check a trigger kickoff context whether to be able to run new execution or not
      */
-    protected final TriggerTransitionContext shouldRun(@NotNull TriggerTransitionContext kickOffContext) {
+    protected final TriggerContext shouldRun(@NotNull TriggerContext kickOffContext) {
         log(Instant.now(), "On evaluate");
         if (state.pending()) {
             return TriggerContextFactory.skip(kickOffContext, ReasonCode.NOT_YET_SCHEDULED);
@@ -190,8 +190,7 @@ protected final TriggerTransitionContext shouldRun(@NotNull TriggerTransitionCon
     /**
      * Check a trigger context whether to be able to stop by configuration or force stop
      */
-    protected final TriggerTransitionContext shouldStop(@NotNull TriggerTransitionContext triggerContext,
-                                                        boolean isForceStop, long round) {
+    protected final TriggerContext shouldStop(@NotNull TriggerContext triggerContext, boolean isForceStop, long round) {
         if (isForceStop) {
             return TriggerContextFactory.stop(triggerContext, ReasonCode.STOP_BY_JOB);
         }
@@ -203,7 +202,7 @@ protected final TriggerTransitionContext shouldStop(@NotNull TriggerTransitionCo
     /**
      * Evaluate a trigger kickoff context on trigger rule
      */
-    protected TriggerTransitionContext evaluateTriggerRule(@NotNull TriggerTransitionContext triggerContext) {
+    protected TriggerContext evaluateTriggerRule(@NotNull TriggerContext triggerContext) {
         if (!triggerContext.isKickoff()) {
             throw new IllegalStateException("Trigger condition status must be " + TriggerStatus.KICKOFF);
         }
@@ -228,48 +227,52 @@ protected final long onFire(long timerId) {
     }
 
     /**
-     * Processing the trigger when the system timer fires
+     * Processing the trigger right away after the system timer fires
      */
-    protected final void onProcess(WorkerExecutor workerExecutor, TriggerTransitionContext kickoffContext) {
-        log(Objects.requireNonNull(kickoffContext.firedAt()), "On fire");
-        this.<TriggerTransitionContext>executeBlocking(workerExecutor,
-                                                       p -> wrapTimeout(timeoutPolicy().evaluationTimeout(),
-                                                                        p).complete(shouldRun(kickoffContext)))
+    protected final void onProcess(WorkerExecutor workerExecutor, TriggerContext ctx) {
+        log(Objects.requireNonNull(ctx.firedAt()), "On fire");
+        final Duration timeout = timeoutPolicy().evaluationTimeout();
+        this.<TriggerContext>executeBlocking(workerExecutor,
+                                             p -> wrapTimeout(timeoutPolicy().evaluationTimeout(), p).complete(
+                                                 shouldRun(ctx)))
             .onSuccess(context -> onTrigger(workerExecutor, context))
-            .onFailure(t -> onMisfire(TriggerContextFactory.skip(kickoffContext, t instanceof TimeoutException
-                                                                                 ? ReasonCode.EVALUATION_TIMEOUT
-                                                                                 : ReasonCode.UNEXPECTED_ERROR, t)));
+            .onFailure(t -> onMisfire(TriggerContextFactory.skip(ctx, t instanceof TimeoutException
+                                                                      ? ReasonCode.EVALUATION_TIMEOUT
+                                                                      : ReasonCode.UNEXPECTED_ERROR, t)));
     }
 
-    protected final void onTrigger(WorkerExecutor workerExecutor, TriggerTransitionContext triggerContext) {
+    protected final void onTrigger(WorkerExecutor workerExecutor, TriggerContext triggerContext) {
         if (!triggerContext.isReady()) {
             onMisfire(triggerContext);
             return;
         }
         final ExecutionContextInternal<OUT> executionContext = new ExecutionContextImpl<>(vertx, triggerContext,
                                                                                           state.increaseRound());
+        final Duration timeout = timeoutPolicy().executionTimeout();
         log(executionContext.triggeredAt(), "On trigger", triggerContext.tick(), executionContext.round());
-        this.executeBlocking(workerExecutor, p -> executeJob(
-                executionContext.setup(wrapTimeout(timeoutPolicy().executionTimeout(), p))))
+        this.executeBlocking(workerExecutor, p -> executeJob(executionContext.setup(wrapTimeout(timeout, p))))
             .onComplete(ar -> onResult(executionContext, ar.cause()));
     }
 
     protected final void onSchedule(long timerId) {
-        final TriggerContext context = TriggerContextFactory.scheduled(trigger().type());
         ExecutionResult<OUT> result;
         if (state.pending()) {
+            final TriggerContext context = TriggerContextFactory.scheduled(trigger().type());
             result = ExecutionResultImpl.<OUT>builder()
                                         .setExternalId(jobData.externalId())
                                         .setAvailableAt(state.markAvailable())
                                         .setTriggerContext(context)
+                                        .setTick(context.tick())
+                                        .setRound(context.tick())
                                         .build();
         } else {
+            final TriggerContext context = TriggerContextFactory.rescheduled(trigger().type(), state.tick());
             result = ExecutionResultImpl.<OUT>builder()
                                         .setExternalId(jobData.externalId())
                                         .setAvailableAt(state.availableAt())
                                         .setTriggerContext(context)
                                         .setRescheduledAt(Instant.now())
-                                        .setTick(state.tick())
+                                        .setTick(context.tick())
                                         .setRound(state.round())
                                         .build();
         }
@@ -282,32 +285,38 @@ protected final void onUnableSchedule(Throwable cause) {
                                                     .setExternalId(jobData.externalId())
                                                     .setTriggerContext(ctx)
                                                     .setUnscheduledAt(Instant.now())
-                                                    .setTick(-1)
-                                                    .setRound(-1)
+                                                    .setTick(ctx.tick())
+                                                    .setRound(ctx.tick())
                                                     .build());
     }
 
-    protected final void onMisfire(@NotNull TriggerTransitionContext triggerContext) {
-        final Instant finishedAt = state.markFinished(triggerContext.tick());
-        log(finishedAt, "On misfire::" + triggerContext.condition().reasonCode(), triggerContext.tick());
+    protected final void onMisfire(@NotNull TriggerContext triggerCtx) {
+        final Instant finishedAt = state.markFinished(triggerCtx.tick());
+        final String reasonCode = triggerCtx.condition().reasonCode();
+        final String event = "On misfire::" + reasonCode;
+        if (ReasonCode.UNEXPECTED_ERROR.equals(reasonCode)) {
+            LOGGER.error(genMsg(triggerCtx.tick(), state.round(), finishedAt, event), triggerCtx.condition().cause());
+        } else {
+            log(finishedAt, event, triggerCtx.tick());
+        }
         monitor.onMisfire(ExecutionResultImpl.<OUT>builder()
                                              .setExternalId(jobData.externalId())
                                              .setAvailableAt(state.availableAt())
-                                             .setTriggerContext(triggerContext)
-                                             .setTick(triggerContext.tick())
-                                             .setFiredAt(triggerContext.firedAt())
+                                             .setTriggerContext(triggerCtx)
+                                             .setTick(triggerCtx.tick())
+                                             .setFiredAt(triggerCtx.firedAt())
                                              .setRound(state.round())
                                              .setFinishedAt(finishedAt)
                                              .build());
     }
 
     protected final void onResult(@NotNull ExecutionContext<OUT> executionContext, @Nullable Throwable asyncCause) {
         final ExecutionContextInternal<OUT> ctx = (ExecutionContextInternal<OUT>) executionContext;
-        final TriggerTransitionContext triggerContext = TriggerContextFactory.executed(ctx.triggerContext());
+        final TriggerContext triggerContext = TriggerContextFactory.executed(ctx.triggerContext());
         final Instant finishedAt = state.markFinished(triggerContext.tick());
         log(finishedAt, "On result", triggerContext.tick(), ctx.round());
         if (asyncCause instanceof TimeoutException) {
-            LOGGER.warn(genMsg(state.tick(), state.round(), finishedAt, asyncCause.getMessage()));
+            LOGGER.warn(genMsg(triggerContext.tick(), ctx.round(), finishedAt, asyncCause.getMessage()));
         } else if (asyncCause != null) {
             LOGGER.error(genMsg(triggerContext.tick(), ctx.round(), finishedAt, "System error"), asyncCause);
         }
@@ -325,7 +334,7 @@ protected final void onResult(@NotNull ExecutionContext<OUT> executionContext, @
                                           .setError(state.addError(ctx.round(),
                                                                    Optional.ofNullable(ctx.error()).orElse(asyncCause)))
                                           .build());
-        final TriggerTransitionContext transitionCtx = shouldStop(triggerContext, ctx.isForceStop(), ctx.round());
+        final TriggerContext transitionCtx = shouldStop(triggerContext, ctx.isForceStop(), ctx.round());
         if (transitionCtx.isStopped()) {
             doStop(state.timerId(), transitionCtx);
         }

core/src/main/java/io/github/zero88/schedulerx/impl/ExecutionContextImpl.java

@@ -5,22 +5,23 @@
 
 import org.jetbrains.annotations.NotNull;
 
+import io.github.zero88.schedulerx.trigger.TriggerContext;
 import io.vertx.core.Promise;
 import io.vertx.core.Vertx;
 
 final class ExecutionContextImpl<OUTPUT> implements ExecutionContextInternal<OUTPUT> {
 
     private final Vertx vertx;
     private final long round;
-    private final TriggerTransitionContext triggerContext;
+    private final TriggerContext triggerContext;
     private final Instant triggeredAt;
     private Instant executedAt;
     private Promise<Object> promise;
     private OUTPUT data;
     private Throwable error;
     private boolean forceStop = false;
 
-    ExecutionContextImpl(Vertx vertx, TriggerTransitionContext triggerContext, long round) {
+    ExecutionContextImpl(Vertx vertx, TriggerContext triggerContext, long round) {
         this.vertx          = vertx;
         this.round          = round;
         this.triggerContext = triggerContext;
@@ -37,9 +38,11 @@ final class ExecutionContextImpl<OUTPUT> implements ExecutionContextInternal<OUT
         return this;
     }
 
-    public @NotNull Vertx vertx()                   { return this.vertx; }
+    @Override
+    public @NotNull Vertx vertx() { return this.vertx; }
 
-    public @NotNull TriggerTransitionContext triggerContext() { return this.triggerContext; }
+    @Override
+    public @NotNull TriggerContext triggerContext() { return this.triggerContext; }
 
     @Override
     public @NotNull Instant triggeredAt() { return this.triggeredAt; }

core/src/main/java/io/github/zero88/schedulerx/impl/ExecutionContextInternal.java

@@ -8,8 +8,6 @@
 
 interface ExecutionContextInternal<OUTPUT> extends ExecutionContext<OUTPUT> {
 
-    @NotNull TriggerTransitionContext triggerContext();
-
     /**
      * Prepare to execute job
      *

core/src/main/java/io/github/zero88/schedulerx/impl/ExecutionResultImpl.java

@@ -147,7 +147,7 @@ public ExecutionResultBuilder<OUTPUT> setRound(long round) {
         }
 
         public ExecutionResultBuilder<OUTPUT> setTriggerContext(TriggerContext triggerContext) {
-            this.triggerContext = TriggerContextFactory.convert(triggerContext);
+            this.triggerContext = triggerContext;
             return this;
         }