Пример #1
0
  /**
   * Schedules a task.
   *
   * @param taskId the task id, used for looking up results and canceling the task
   * @param task the task
   * @param recurs <tt>true</tt> if this is a recurring task
   * @param intervalMillis number of milliseconds between executions of a recurring task, measured
   *     between the end of the last execution and the start of the next
   * @param delayMillis number of milliseconds to wait before the first execution
   */
  public void schedule(
      Object taskId, Callable<V> task, boolean recurs, long intervalMillis, long delayMillis) {
    ZimbraLog.scheduler.debug("Scheduling task %s", taskId);

    TaskRunner<V> runner = new TaskRunner<V>(taskId, task, recurs, intervalMillis, mCallbacks);
    runner.mSchedule = mThreadPool.schedule(runner, delayMillis, TimeUnit.MILLISECONDS);
    mRunnerMap.put(taskId, runner);
  }
Пример #2
0
 /**
  * Returns the <tt>Callable</tt> object for the given <tt>taskId</tt>, or <tt>null</tt> if no
  * matching task exists.
  */
 public Callable<V> getTask(Object taskId) {
   TaskRunner<V> runner = mRunnerMap.get(taskId);
   if (runner == null) {
     return null;
   }
   if (runner.mSchedule.isCancelled()) {
     return null;
   }
   return runner.getTask();
 }
Пример #3
0
 /**
  * Cancels a task.
  *
  * @return the task, or <tt>null</tt> if the task couldn't be found.
  */
 public Callable<V> cancel(Object taskId, boolean mayInterruptIfRunning) {
   // Don't remove the task runner, so that users can get the last result
   // after a task has been canceled.
   TaskRunner<V> runner = mRunnerMap.get(taskId);
   if (runner == null) {
     return null;
   }
   ZimbraLog.scheduler.debug("Cancelling task %s", taskId);
   runner.mSchedule.cancel(mayInterruptIfRunning);
   return runner.getTask();
 }
Пример #4
0
 // Most of the tests in this file were written when task event
 // notification was done synchronously in TaskRunner.  Reproduce that
 // behavior here for simplicity.
 void notify(SchedulableTask task, Schedule.EventType eventType) {
   if (doImmediateNotify) {
     task.callback.taskEvent(task, eventType);
   } else {
     super.notify(task, eventType);
   }
 }
Пример #5
0
 public synchronized boolean stop() {
   // 停止任务,并取消和线程的绑定,并移除block runner,再次启动的时候创建新的block runner
   if (!isRunning) {
     return true;
   }
   if (currentRunner != null) {
     currentRunner.stop();
   }
   currentRunner = null;
   isRunning = false;
   return true;
 }
Пример #6
0
 public TaskRunner create(
     final long delay, final String containerId, final TaskRunner.Listener listener) {
   return TaskRunner.builder()
       .delayMillis(delay)
       .config(taskConfig)
       .docker(docker)
       .healthChecker(healthChecker.orNull())
       .existingContainerId(containerId)
       .listener(new BroadcastingListener(concat(this.listeners, asList(listener))))
       .registrar(registrar)
       .build();
 }
Пример #7
0
 public synchronized boolean start() {
   // 如果已经启动了,则直接返回,否则开启任务
   if (isRunning) {
     return true;
   }
   if (executor == null || executor.isShutdown()) {
     return false;
   }
   isRunning = true;
   currentRunner = new TaskRunner();
   Future<TaskRunner> f = executor.submit(currentRunner, currentRunner);
   currentRunner.boundFutrue(f);
   return true;
 }
Пример #8
0
 void removeTask(StepTask task) {
   removedTasks.add(task);
   super.removeTask(task);
 }
Пример #9
0
 void removeChunk(Schedule.Chunk chunk) {
   removedChunks.add(chunk);
   super.removeChunk(chunk);
 }