protected <T> ScheduledTask<T> schedule(String id, String name, String type, Callable<T> callable, Schedule schedule, boolean enabled, boolean store) { DefaultScheduledTask<T> dct = new DefaultScheduledTask<T>(id, name, type, this, callable, schedule); dct.setEnabled(enabled); addToTasksMap(dct, store); dct.start(); return dct; }
public void cancelOnly() { cancel(false, getScheduleIterator().isFinished()); }
public void runNow() { // if we are not RUNNING if (!TaskState.RUNNING.equals(getTaskState()) && !manualRun) { manualRun = true; if (getFuture() != null) { //as bentmann mentioned, there is potential for the future to have started running between the check on our if above and now //so we force interrupt it getFuture().cancel(true); } setFuture(doSchedule(-1, true)); } }
public void reset() { final ProgressListener progressListener = getProgressListener(); if (progressListener != null) { progressListener.cancel(); } // to prevent starting it if not yet started if (getFuture() != null) { getFuture().cancel(false); } setTaskState(TaskState.SUBMITTED); reschedule(true); }
this.progressListener = new LoggingProgressListener(getCallable().getClass().getSimpleName()); if (getCallable() instanceof SchedulerTask) { if (!((SchedulerTask<?>) getCallable()).allowConcurrentExecution(getScheduler().getActiveTasks())) { if (nextRun != null) { setFuture(getScheduler().getScheduledExecutorService().schedule(this, 10000, TimeUnit.MILLISECONDS)); setTaskState(TaskState.SLEEPING); if ((isEnabled() || manualRun) && getTaskState().isRunnable()) { setTaskState(TaskState.RUNNING); nextMillis = reschedule(false); setLastRun(startDate); peekBefore = getScheduleIterator().peekNext(); result = getCallable().call(); peekAfter = getScheduleIterator().peekNext(); setLastStatus(TaskState.FINISHED); logger.warn("Exception in call method of scheduled task {}", getName(), e); peekAfter = getScheduleIterator().peekNext();
public void cancel( boolean interrupt, boolean removeTask ) final ProgressListener progressListener = getProgressListener(); TaskState originalState = getTaskState(); setTaskState( TaskState.CANCELLING ); if ( getFuture() != null ) getFuture().cancel( interrupt ); setLastRun( new Date() ); if ( getScheduleIterator().isFinished() ) reschedule( true ); TaskState newState = isManualRunScheduled() ? TaskState.SUBMITTED : TaskState.WAITING; setTaskState( newState ); setToBeRemoved( removeTask ); setTaskState( TaskState.CANCELLED ); getScheduler().removeFromTasksMap( this );
protected long reschedule(boolean setFuture) { if (!isManualRunScheduled()) { SchedulerIterator iter = getScheduleIterator(); if (iter != null && !iter.isFinished()) { nextRun = iter.next(); long nextTime = 0; if (nextRun != null) { nextTime = nextRun.getTime(); } else { nextTime = System.currentTimeMillis(); } getScheduler().taskRescheduled(this); if (setFuture) { setFuture(doSchedule(nextTime, iter instanceof RunNowSchedulerIterator)); } return nextTime; } else { nextRun = null; } } else { nextRun = null; } return -1; }
public T getIfDone() { if (TaskState.FINISHED.equals(getTaskState())) { try { return getFuture().get(); } catch (ExecutionException e) { return null; } catch (InterruptedException e) { return null; } } else { return null; } }
scheduledTask.setLastRun( new Date( task.getLastRun() ) );
protected boolean isManualRunScheduled() { return ManualRunSchedule.class.isAssignableFrom( getSchedule().getClass() ); }
public void cancel(boolean interrupt) { cancel(interrupt, true); }
public T get() throws ExecutionException, InterruptedException { return getFuture().get(); }
public Map<String, String> getTaskParams() { if (SchedulerTask.class.isAssignableFrom(getCallable().getClass())) { return ((SchedulerTask<?>) getCallable()).getParameters(); } return Collections.emptyMap(); }
this.progressListener = new LoggingProgressListener( getCallable().getClass().getSimpleName() ); if ( getCallable() instanceof SchedulerTask ) if ( !( (SchedulerTask<?>) getCallable() ).allowConcurrentExecution( getScheduler().getActiveTasks() ) ) setFuture( getScheduler().getScheduledExecutorService().schedule( this, 10000, TimeUnit.MILLISECONDS ) ); setTaskState( TaskState.SLEEPING ); if ( ( isEnabled() || manualRun ) && getTaskState().isRunnable() ) setTaskState( TaskState.RUNNING ); nextMillis = reschedule( false ); setLastRun( startDate ); peekBefore = getScheduleIterator().peekNext(); result = getCallable().call(); peekAfter = getScheduleIterator().peekNext(); setLastStatus( TaskState.FINISHED ); logger.warn( "Exception in call method of scheduled task {}", getName(), e ); peekAfter = getScheduleIterator().peekNext();
public void cancel(boolean interrupt, boolean removeTask) { final ProgressListener progressListener = getProgressListener(); TaskState originalState = getTaskState(); setTaskState(TaskState.CANCELLING); if (getFuture() != null) { getFuture().cancel(interrupt); setLastRun(new Date()); if (getScheduleIterator().isFinished()) { removeTask = true; reschedule(true); TaskState newState = isManualRunScheduled() ? TaskState.SUBMITTED : TaskState.WAITING; setTaskState(newState); setToBeRemoved(removeTask); setTaskState(TaskState.CANCELLED); getScheduler().removeFromTasksMap(this);
protected long reschedule( boolean setFuture ) if ( !isManualRunScheduled() ) SchedulerIterator iter = getScheduleIterator(); getScheduler().taskRescheduled( this ); setFuture( doSchedule( nextTime ) );
public void reset() { final ProgressListener progressListener = getProgressListener(); if ( progressListener != null ) { progressListener.cancel(); } // to prevent starting it if not yet started if ( getFuture() != null ) { getFuture().cancel( false ); } setTaskState( TaskState.SUBMITTED ); reschedule( true ); }
public T getIfDone() { if ( TaskState.FINISHED.equals( getTaskState() ) ) { try { return getFuture().get(); } catch ( ExecutionException e ) { return null; } catch ( InterruptedException e ) { return null; } } else { return null; } }
protected boolean isManualRunScheduled() { return ManualRunSchedule.class.isAssignableFrom(getSchedule().getClass()); }
public void cancel() { cancel(false); }