How to use

equals

method

in

org.sonatype.scheduling.TaskState

public boolean isEndingState() {
   /* I don't think BROKEN should apply, broken simply means an exception was thrown.
    * So what?  let the user attempt to do it again, maybe an fs perm problem that they resolved */
 return this.equals(FINISHED) || this.equals(CANCELLED);
}

public boolean isActiveOrSubmitted() {
 return this.equals(SUBMITTED) || this.equals(RUNNING) || this.equals(SLEEPING) || this.equals(WAITING)
   || this.equals(CANCELLING);
}

public boolean isRunnable() {
 return this.equals(SUBMITTED) || this.equals(RUNNING) || this.equals(SLEEPING) || this.equals(WAITING) ||
   this.equals(BROKEN);
}

public boolean isExecuting() {
 return this.equals(RUNNING) || this.equals(CANCELLING);
}

public boolean isActiveOrSubmitted()
{
  return this.equals( SUBMITTED ) || this.equals( RUNNING ) || this.equals( SLEEPING ) || this.equals( WAITING )
    || this.equals( CANCELLING );
}

public boolean isEndingState()
{
  /* I don't think BROKEN should apply, broken simply means an exception was thrown.
   * So what?  let the user attempt to do it again, maybe an fs perm problem that they resolved */
  return this.equals( FINISHED ) || this.equals( CANCELLED );
}

public boolean isRunnable()
{
  return this.equals( SUBMITTED ) || this.equals( RUNNING ) || this.equals( SLEEPING ) || this.equals( WAITING ) || this.equals( BROKEN );
}

public boolean isExecuting()
{
  return this.equals( RUNNING ) || this.equals( CANCELLING );
}

public boolean isActive() {
 return this.equals(RUNNING) || this.equals(SLEEPING) || this.equals(WAITING) || this.equals(CANCELLING);
}

public boolean isActive()
{
  return this.equals( RUNNING ) || this.equals( SLEEPING ) || this.equals( WAITING ) || this.equals( CANCELLING );
}

private boolean isSubmitted(ScheduledTask<?> scheduledTask) {
 return SUBMITTED.equals(scheduledTask.getTaskState()) || SLEEPING.equals(scheduledTask.getTaskState());
}

public boolean allowConcurrentExecution( Map<String, List<ScheduledTask<?>>> activeTasks )
{
  // most basic check: simply not allowing multiple execution of instances of this class
  // override if needed
  if ( activeTasks.containsKey( this.getClass().getSimpleName() ) )
  {
    for ( ScheduledTask<?> task : activeTasks.get( this.getClass().getSimpleName() ) )
    {
      if ( TaskState.RUNNING.equals( task.getTaskState() ) )
      {
        return false;
      }
    }
    return true;
  }
  else
  {
    return true;
  }
}

 public Map<String, List<ScheduledTask<?>>> getRunningTasks() {
  Map<String, List<ScheduledTask<?>>> result = getAllTasks();
  List<ScheduledTask<?>> tasks = null;

  // filter for RUNNING
  for (Iterator<String> c = result.keySet().iterator(); c.hasNext(); ) {
   String cls = c.next();
   tasks = result.get(cls);

   for (Iterator<ScheduledTask<?>> i = tasks.iterator(); i.hasNext(); ) {
    ScheduledTask<?> task = i.next();

    if (!TaskState.RUNNING.equals(task.getTaskState())) {
     i.remove();
    }
   }

   if (tasks.isEmpty()) {
    c.remove();
   }
  }

  return result;
 }
}

  public Map<String, List<ScheduledTask<?>>> getRunningTasks()
  {
    Map<String, List<ScheduledTask<?>>> result = getAllTasks();
    List<ScheduledTask<?>> tasks = null;

    // filter for RUNNING
    for ( Iterator<String> c = result.keySet().iterator(); c.hasNext(); )
    {
      String cls = c.next();
      tasks = result.get( cls );

      for ( Iterator<ScheduledTask<?>> i = tasks.iterator(); i.hasNext(); )
      {
        ScheduledTask<?> task = i.next();

        if ( !TaskState.RUNNING.equals( task.getTaskState() ) )
        {
          i.remove();
        }
      }

      if ( tasks.isEmpty() )
      {
        c.remove();
      }
    }

    return result;
  }
}

@Override
public boolean allowConcurrentExecution(Map<String, List<ScheduledTask<?>>> activeTasks) {
 if (activeTasks.containsKey(ID)) {
  for (ScheduledTask<?> scheduledTask : activeTasks.get(ID)) {
   if (RUNNING.equals(scheduledTask.getTaskState())) {
    if (conflictsWith((MergeMetadataTask) scheduledTask.getTask())) {
     return false;
    }
   }
  }
 }
 return 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;
 }
}

@Override
public boolean allowConcurrentExecution(Map<String, List<ScheduledTask<?>>> activeTasks) {
 if (activeTasks.containsKey(ID)) {
  int activeRunningTasks = 0;
  for (ScheduledTask<?> scheduledTask : activeTasks.get(ID)) {
   if (RUNNING.equals(scheduledTask.getTaskState())) {
    if (conflictsWith((GenerateMetadataTask) scheduledTask.getTask())) {
     return false;
    }
    activeRunningTasks++;
   }
  }
  return activeRunningTasks < yumRegistry.maxNumberOfParallelThreads();
 }
 return true;
}

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 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( 0 ) );
  }
}

protected String getLastRunResult(ScheduledTask<?> task) {
 String lastRunResult = "n/a";
 if (task.getLastStatus() != null) {
  lastRunResult = TaskState.BROKEN.equals(task.getLastStatus()) ? "Error" : "Ok";
  if (task.getDuration() != 0) {
   long milliseconds = task.getDuration();
   int hours = (int) ((milliseconds / 1000) / 3600);
   int minutes = (int) ((milliseconds / 1000) / 60 - hours * 60);
   int seconds = (int) ((milliseconds / 1000) % 60);
   lastRunResult += " [";
   if (hours != 0) {
    lastRunResult += hours;
    lastRunResult += "h";
   }
   if (minutes != 0 || hours != 0) {
    lastRunResult += minutes;
    lastRunResult += "m";
   }
   lastRunResult += seconds;
   lastRunResult += "s";
   lastRunResult += "]";
  }
 }
 return lastRunResult;
}