/** * Return a {@link ScheduledCompletableFuture} that resolves at the given epochTime and runs the runnable. * * @param runnable Runs at the given epochTime * @param instant The epoch time * @return A {@link ScheduledCompletableFuture} */ default ScheduledCompletableFuture<@Nullable Void> at(SchedulerRunnable runnable, Instant instant) { return at(() -> { runnable.run(); return null; }, instant); }
@Override public long getDelay(@Nullable TimeUnit timeUnit) { return scheduledPromise == null ? 0 : scheduledPromise.getDelay(timeUnit); } }
@Override public ScheduledCompletableFuture<@Nullable Void> schedule(CronJob job, Map<String, Object> config, String cronExpression) { final CronAdjuster cronAdjuster = new CronAdjuster(cronExpression); final SchedulerRunnable runnable = () -> { job.run(config); }; if (cronAdjuster.isReboot()) { return scheduler.at(runnable, Instant.ofEpochMilli(1)); } else { return scheduler.schedule(runnable, cronAdjuster); } }
void removeSchedule(CronJob s) { synchronized (crons) { for (Iterator<Cron> cron = crons.iterator(); cron.hasNext();) { final Cron c = cron.next(); if (c.target == s) { cron.remove(); c.schedule.cancel(true); } } } }
void setScheduledPromise(ScheduledCompletableFuture<T> future) { synchronized (this) { if (isCancelled()) { // if already cancelled stop the new future directly. future.cancel(true); } else { scheduledPromise = future; scheduledPromise.getPromise().exceptionally(ex -> { // if an error occurs in the scheduled job propagate to parent ScheduledCompletableFutureRecurring.this.completeExceptionally(ex); return null; }); } } }
private <T> void schedule(ScheduledCompletableFutureRecurring<T> schedule, SchedulerRunnable runnable, SchedulerTemporalAdjuster temporalAdjuster) { final Temporal newTime = ZonedDateTime.now(clock).with(temporalAdjuster); final ScheduledCompletableFutureOnce<T> deferred = new ScheduledCompletableFutureOnce<>(); deferred.thenAccept(v -> { if (temporalAdjuster.isDone(newTime)) { schedule.complete(v); } else { schedule(schedule, runnable, temporalAdjuster); } }); schedule.setScheduledPromise(deferred); atInternal(deferred, () -> { runnable.run(); return null; }, Instant.from(newTime)); }
public GenericCronTriggerHandler(Trigger module) { super(module); String cronExpressionString = (String) module.getConfiguration().get(CFG_CRON_EXPRESSION); try { expression = new CronExpression(cronExpressionString); } catch (ParseException e) { throw new IllegalArgumentException( "'" + cronExpressionString + "' parameter is not in valid cron expression.", e); } scheduler = ExpressionThreadPoolManager.getExpressionScheduledPool(TimerModuleHandlerFactory.THREADPOOLNAME); }
@Override public <T> ScheduledCompletableFuture<T> schedule(SchedulerRunnable runnable, Duration... delays) { return scheduler.schedule(runnable, new PeriodicAdjuster(delays)); }
private <T> ScheduledCompletableFuture<T> add(ScheduledCompletableFuture<T> t) { synchronized (scheduledJobs) { scheduledJobs.add(t); } t.getPromise().handle((v, e) -> { synchronized (scheduledJobs) { scheduledJobs.remove(t); return v; } }); return t; }
@Override public ScheduledCompletableFuture<@Nullable Void> schedule(SchedulerRunnable runnable, String cronExpression) { return schedule(d -> runnable.run(), Collections.emptyMap(), cronExpression); }
protected void activate() { scheduler = ExpressionThreadPoolManager.getExpressionScheduledPool("persist"); }
protected void deactivate() { scheduler.shutdown(); scheduler = null; }
public ScheduledCompletableFutureRecurring() { exceptionally(e -> { synchronized (this) { if (e instanceof CancellationException) { if (scheduledPromise != null) { scheduledPromise.cancel(true); } } } return null; }); }
@Override public ScheduledCompletableFuture<@Nullable Void> schedule(CronJob job, Map<String, Object> config, String cronExpression) { final CronAdjuster cronAdjuster = new CronAdjuster(cronExpression); final SchedulerRunnable runnable = () -> { job.run(config); }; if (cronAdjuster.isReboot()) { return scheduler.at(runnable, Instant.ofEpochMilli(1)); } else { return scheduler.schedule(runnable, cronAdjuster); } }
/** * Return a {@link ScheduledCompletableFuture} that resolves at the given epochTime and runs the runnable. * * @param runnable Runs at the given epochTime * @param instant The epoch time * @return A {@link ScheduledCompletableFuture} */ default ScheduledCompletableFuture<@Nullable Void> at(SchedulerRunnable runnable, Instant instant) { return at(() -> { runnable.run(); return null; }, instant); }
@Override public long getDelay(@Nullable TimeUnit timeUnit) { return scheduledPromise == null ? 0 : scheduledPromise.getDelay(timeUnit); } }
@Override public <T> ScheduledCompletableFuture<T> schedule(SchedulerRunnable runnable, Duration... delays) { return scheduler.schedule(runnable, new PeriodicAdjuster(delays)); }
@Deactivate void deactivate() { while (!scheduledJobs.isEmpty()) { final ScheduledCompletableFuture<?> scheduledJob; synchronized (scheduledJobs) { if (scheduledJobs.isEmpty()) { return; } Iterator<ScheduledCompletableFuture<?>> iterator = scheduledJobs.iterator(); scheduledJob = iterator.next(); iterator.remove(); } scheduledJob.cancel(true); } }
void removeSchedule(CronJob s) { synchronized (crons) { for (Iterator<Cron> cron = crons.iterator(); cron.hasNext();) { final Cron c = cron.next(); if (c.target == s) { cron.remove(); c.schedule.cancel(true); } } } }
public ScheduledCompletableFutureRecurring() { exceptionally(e -> { synchronized (this) { if (e instanceof CancellationException) { if (scheduledPromise != null) { scheduledPromise.cancel(true); } } } return null; }); }