@Override public int hashCode() { return Objects.hash(pendingTask.getPendingTaskId()); }
public void savePendingTask(SingularityPendingTask pendingTask) { if (!active) { LOG.warn("savePendingTask {}, but not active", pendingTask); return; } pendingTaskIdToPendingTask.put(pendingTask.getPendingTaskId(), pendingTask); }
public void cachePendingTasks(List<SingularityPendingTask> pendingTasks) { pendingMissMeter.mark(); Map<SingularityPendingTaskId, SingularityPendingTask> newPendingTasks = new HashMap<>(pendingTasks.size()); for (SingularityPendingTask pendingTask : pendingTasks) { newPendingTasks.put(pendingTask.getPendingTaskId(), pendingTask); } cachedPendingTasks = newPendingTasks; lastPendingTaskCache = System.currentTimeMillis(); }
public void cachePendingTasks(List<SingularityPendingTask> pendingTasks) { this.pendingTaskIdToPendingTask = new ConcurrentHashMap<>(pendingTasks.size()); pendingTasks.forEach((t) -> pendingTaskIdToPendingTask.put(t.getPendingTaskId(), t)); }
@Override public String apply(@Nonnull SingularityPendingTask input) { return input.getPendingTaskId().getRequestId(); } };
@Override public boolean apply(@Nonnull SingularityPendingTask input) { return input.getPendingTaskId().getRequestId().equals(requestId); }
@Override public boolean apply(@Nonnull SingularityPendingTask input) { return input.getPendingTaskId().getDeployId().equals(deployId); }
private void deleteScheduledTasks(final Collection<SingularityPendingTask> scheduledTasks, SingularityPendingRequest pendingRequest) { List<SingularityPendingTask> tasksForDeploy = scheduledTasks .stream() .filter(task -> pendingRequest.getRequestId().equals(task.getPendingTaskId().getRequestId())) .filter(task -> pendingRequest.getDeployId().equals(task.getPendingTaskId().getDeployId())) .collect(Collectors.toList()); for (SingularityPendingTask task : tasksForDeploy) { LOG.debug("Deleting pending task {} in order to reschedule {}", task.getPendingTaskId().getId(), pendingRequest); taskManager.deletePendingTask(task.getPendingTaskId()); } }
@Override public int compareTo(SingularityTaskRequest o) { return this.getPendingTask().getPendingTaskId().compareTo(o.getPendingTask().getPendingTaskId()); }
public static SingularityDeployKey fromPendingTask(SingularityPendingTask pendingTask) { return new SingularityDeployKey(pendingTask.getPendingTaskId().getRequestId(), pendingTask.getPendingTaskId().getDeployId()); }
private List<SingularityTaskRequestHolder> getSortedDueTaskRequests() { final List<SingularityTaskRequest> taskRequests = taskPrioritizer.getSortedDueTasks(scheduler.getDueTasks()); taskRequests.forEach((taskRequest) -> LOG.trace("Task {} is due", taskRequest.getPendingTask().getPendingTaskId())); taskPrioritizer.removeTasksAffectedByPriorityFreeze(taskRequests); return taskRequests.stream() .map((taskRequest) -> new SingularityTaskRequestHolder(taskRequest, defaultResources, defaultCustomExecutorResources)) .collect(Collectors.toList()); }
@Timed public List<SingularityTaskRequest> getDueTasks() { final List<SingularityPendingTask> tasks = taskManager.getPendingTasks(); final long now = System.currentTimeMillis(); final List<SingularityPendingTask> dueTasks = Lists.newArrayListWithCapacity(tasks.size()); for (SingularityPendingTask task : tasks) { if (task.getPendingTaskId().getNextRunAt() <= now) { dueTasks.add(task); } } final List<SingularityTaskRequest> dueTaskRequests = taskRequestManager.getTaskRequests(dueTasks); return checkForStaleScheduledTasks(dueTasks, dueTaskRequests); }
private double getWeightedPriority(SingularityTaskRequest taskRequest, long now) { Long overdueMillis = Math.max(now - taskRequest.getPendingTask().getPendingTaskId().getNextRunAt(), 1); Double requestPriority = priorityManager.getTaskPriorityLevelForRequest(taskRequest.getRequest()); return overdueMillis * Math.pow(requestPriority, configuration.getSchedulerPriorityWeightFactor()); }
public void removeTasksAffectedByPriorityFreeze(List<SingularityTaskRequest> taskRequests) { final Optional<SingularityPriorityFreezeParent> maybePriorityFreeze = priorityManager.getActivePriorityFreeze(); if (maybePriorityFreeze.isPresent()) { final ListIterator<SingularityTaskRequest> iterator = taskRequests.listIterator(); while (iterator.hasNext()) { final SingularityTaskRequest taskRequest = iterator.next(); final double taskPriorityLevel = priorityManager.getTaskPriorityLevelForRequest(taskRequest.getRequest()); if (taskPriorityLevel < maybePriorityFreeze.get().getPriorityFreeze().getMinimumPriorityLevel()) { LOG.trace("Skipping scheduled task {} because taskPriorityLevel ({}) is less than active priority freeze ({})", taskRequest.getPendingTask().getPendingTaskId(), taskPriorityLevel, maybePriorityFreeze.get().getPriorityFreeze().getMinimumPriorityLevel()); iterator.remove(); } } } }
public SingularityCreateResult savePendingTask(SingularityPendingTask task) { final String pendingPath = getPendingPath(task.getPendingTaskId()); leaderCache.savePendingTask(task); return save(pendingPath, task, pendingTaskTranscoder); }
private double calculateScore(SingularityOfferHolder offerHolder, Map<String, SingularitySlaveUsageWithCalculatedScores> currentSlaveUsagesBySlaveId, Map<String, Integer> tasksPerOffer, SingularityTaskRequestHolder taskRequestHolder, List<SingularityTaskId> activeTaskIdsForRequest, RequestUtilization requestUtilization) { Optional<SingularitySlaveUsageWithCalculatedScores> maybeSlaveUsage = Optional.fromNullable(currentSlaveUsagesBySlaveId.get(offerHolder.getSlaveId())); double score = score(offerHolder, tasksPerOffer, taskRequestHolder, maybeSlaveUsage, activeTaskIdsForRequest, requestUtilization); if (LOG.isTraceEnabled()) { LOG.trace("Scored {} | Task {} | Offer - mem {} - cpu {} | Slave {} | maybeSlaveUsage - {}", score, taskRequestHolder.getTaskRequest().getPendingTask().getPendingTaskId().getId(), MesosUtils.getMemory(offerHolder.getCurrentResources(), Optional.absent()), MesosUtils.getNumCpus(offerHolder.getCurrentResources(), Optional.absent()), offerHolder.getHostname(), maybeSlaveUsage); } return score; }
private boolean shouldRetryImmediately(SingularityRequest request, SingularityDeployStatistics deployStatistics, Optional<SingularityTask> task) { if (!request.getNumRetriesOnFailure().isPresent()) { return false; } if (task.isPresent() && task.get().getTaskRequest().getPendingTask().getPendingTaskId().getPendingType() == PendingType.IMMEDIATE && request.getRequestType() == RequestType.SCHEDULED) { return false; // don't retry UI triggered scheduled jobs (UI triggered on-demand jobs are okay to retry though) } final int numRetriesInARow = deployStatistics.getNumSequentialRetries(); if (numRetriesInARow >= request.getNumRetriesOnFailure().get()) { LOG.debug("Request {} had {} retries in a row, not retrying again (num retries on failure: {})", request.getId(), numRetriesInARow, request.getNumRetriesOnFailure()); return false; } LOG.debug("Request {} had {} retries in a row - retrying again (num retries on failure: {})", request.getId(), numRetriesInARow, request.getNumRetriesOnFailure()); return true; }
@Before public void setup() { Mockito.when(taskRequest.getRequest()).thenReturn(request); Mockito.when(request.getId()).thenReturn("requestId"); Mockito.when(taskRequest.getDeploy()).thenReturn(deploy); Mockito.when(deploy.getId()).thenReturn("deployId"); Mockito.when(taskRequest.getPendingTask()).thenReturn(task); Mockito.when(task.getPendingTaskId()).thenReturn(taskId); }
public Optional<SingularityPendingTask> deleteScheduledTask(String taskId, SingularityUser user) { Optional<SingularityPendingTask> maybePendingTask = taskManager.getPendingTask(getPendingTaskIdFromStr(taskId)); if (maybePendingTask.isPresent()) { SingularityPendingTaskId pendingTaskId = maybePendingTask.get().getPendingTaskId(); Optional<SingularityRequestWithState> maybeRequest = requestManager.getRequest(pendingTaskId.getRequestId()); checkNotFound(maybeRequest.isPresent(), "Couldn't find: " + taskId); SingularityRequest request = maybeRequest.get().getRequest(); authorizationHelper.checkForAuthorizationByRequestId(request.getId(), user, SingularityAuthorizationScope.WRITE); checkBadRequest(request.getRequestType() == RequestType.ON_DEMAND, "Only ON_DEMAND tasks may be deleted."); taskManager.markPendingTaskForDeletion(pendingTaskId); } return maybePendingTask; }
public static SingularityTaskState fromTaskHistory(SingularityTaskHistory taskHistory) { return new SingularityTaskState( Optional.of(taskHistory.getTask().getTaskId()), Optional.of(taskHistory.getTask().getTaskRequest().getPendingTask().getPendingTaskId()), taskHistory.getTask().getTaskRequest().getPendingTask().getRunId(), Optional.of(taskHistory.getLastTaskUpdate().get().getTaskState()), taskHistory.getTaskUpdates(), false ); }