@Override public String apply(@Nonnull SingularityPendingTaskId input) { return input.getRequestId(); } };
@Override public boolean apply(@Nonnull SingularityPendingTaskId input) { return input.getRequestId().equals(requestId); }
public List<SingularityPendingTaskId> getPendingTaskIdsForRequest(String requestId) { Set<SingularityPendingTaskId> allPendingTaskIds = new HashSet<>(pendingTaskIdToPendingTask.keySet()); return allPendingTaskIds.stream() .filter(t -> t.getRequestId().equals(requestId)) .collect(Collectors.toList()); }
@Override public String apply(@Nonnull SingularityPendingTask input) { return input.getPendingTaskId().getRequestId(); } };
public List<SingularityPendingTaskId> getPendingTaskIdsForRequest(final String requestId) { List<SingularityPendingTaskId> pendingTaskIds = getPendingTaskIds(); return pendingTaskIds.stream() .filter(pendingTaskId -> pendingTaskId.getRequestId().equals(requestId)) .collect(Collectors.collectingAndThen(Collectors.toList(), ImmutableList::copyOf)); }
@Override public boolean apply(@Nonnull SingularityPendingTask input) { return input.getPendingTaskId().getRequestId().equals(requestId); }
private Map<SingularityDeployKey, SingularityPendingTaskId> getDeployKeyToPendingTaskId() { final List<SingularityPendingTaskId> pendingTaskIds = taskManager.getPendingTaskIds(); final Map<SingularityDeployKey, SingularityPendingTaskId> deployKeyToPendingTaskId = Maps.newHashMapWithExpectedSize(pendingTaskIds.size()); for (SingularityPendingTaskId taskId : pendingTaskIds) { SingularityDeployKey deployKey = new SingularityDeployKey(taskId.getRequestId(), taskId.getDeployId()); deployKeyToPendingTaskId.put(deployKey, taskId); } return deployKeyToPendingTaskId; }
private boolean requestTypeIsOnDemand(SingularityPendingTaskId taskId) { if (requestManager.getRequest(taskId.getRequestId()).isPresent()) { return requestManager.getRequest(taskId.getRequestId()).get().getRequest().getRequestType().equals(RequestType.ON_DEMAND); } return false; }
@Override public int compareTo(SingularityPendingTaskId o) { return ComparisonChain.start() .compare(this.getNextRunAt(), o.getNextRunAt()) .compare(this.getRequestId(), o.getRequestId()) .compare(this.getDeployId(), o.getDeployId()) .compare(this.getInstanceNo(), o.getInstanceNo()) .compare(this.getCreatedAt(), o.getCreatedAt()) .compare(this.getPendingType(), o.getPendingType()) .result(); }
private void deleteObsoletePendingTasks(SingularityPendingDeploy pendingDeploy) { List<SingularityPendingTaskId> obsoletePendingTasks = taskManager.getPendingTaskIds() .stream() .filter(taskId -> taskId.getRequestId().equals(pendingDeploy.getDeployMarker().getRequestId())) .filter(taskId -> !taskId.getDeployId().equals(pendingDeploy.getDeployMarker().getDeployId())) .collect(Collectors.toList()); for (SingularityPendingTaskId pendingTaskId : obsoletePendingTasks) { LOG.debug("Deleting obsolete pending task {}", pendingTaskId.getId()); taskManager.deletePendingTask(pendingTaskId); } }
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()); } }
public List<SingularityTaskRequest> getTaskRequests(List<SingularityPendingTask> tasks) { final Multimap<String, SingularityPendingTask> requestIdToPendingTaskId = ArrayListMultimap.create(tasks.size(), 1); for (SingularityPendingTask task : tasks) { requestIdToPendingTaskId.put(task.getPendingTaskId().getRequestId(), task); } final List<SingularityRequestWithState> matchingRequests = requestManager.getRequests(requestIdToPendingTaskId.keySet()); final Map<SingularityPendingTask, SingularityDeployKey> deployKeys = SingularityDeployKey.fromPendingTasks(requestIdToPendingTaskId.values()); final Map<SingularityDeployKey, SingularityDeploy> matchingDeploys = deployManager.getDeploysForKeys(Sets.newHashSet(deployKeys.values())); final List<SingularityTaskRequest> taskRequests = Lists.newArrayListWithCapacity(matchingRequests.size()); for (SingularityRequestWithState request : matchingRequests) { Optional<SingularityPendingDeploy> maybePendingDeploy = deployManager.getPendingDeploy(request.getRequest().getId()); for (SingularityPendingTask task : requestIdToPendingTaskId.get(request.getRequest().getId())) { SingularityDeploy foundDeploy = matchingDeploys.get(deployKeys.get(task)); if (foundDeploy == null) { LOG.warn("Couldn't find a matching deploy for pending task {}", task); continue; } if (!request.getState().isRunnable()) { LOG.warn("Request was in state {} for pending task {}", request.getState(), task); continue; } Optional<SingularityRequest> updatedRequest = maybePendingDeploy.isPresent() && maybePendingDeploy.get().getDeployMarker().getDeployId().equals(task.getPendingTaskId().getDeployId()) ? maybePendingDeploy.get().getUpdatedRequest() : Optional.<SingularityRequest>absent(); taskRequests.add(new SingularityTaskRequest(updatedRequest.or(request.getRequest()), foundDeploy, task)); } } return taskRequests; }
public static SingularityDeployKey fromPendingTask(SingularityPendingTask pendingTask) { return new SingularityDeployKey(pendingTask.getPendingTaskId().getRequestId(), pendingTask.getPendingTaskId().getDeployId()); }
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; }
envVars.put("AVAILABILITY_ZONE", offerHolder.getRackId()); envVars.put("TASK_REQUEST_ID", task.getPendingTask().getPendingTaskId().getRequestId()); envVars.put("TASK_DEPLOY_ID", taskId.getDeployId()); envVars.put("TASK_ID", taskId.getId());
private Map<String, Long> getNumTasks(List<SingularityRequestWithState> requests) { final CounterMap<String> numTasks = new CounterMap<>(requests.size()); for (SingularityTaskId taskId : taskManager.getActiveTaskIds()) { numTasks.incr(taskId.getRequestId()); } for (SingularityPendingTaskId pendingTaskId : taskManager.getPendingTaskIds()) { numTasks.incr(pendingTaskId.getRequestId()); } for (SingularityTaskId cleaningTaskId : taskManager.getCleanupTaskIds()) { Optional<SingularityRequestWithState> request = requestManager.getRequest(cleaningTaskId.getRequestId()); if (request.isPresent() && request.get().getRequest().isScheduled()) { continue; } numTasks.decr(cleaningTaskId.getRequestId()); } return numTasks.toCountMap(); }
final long fiveHoursInMilliseconds = TimeUnit.HOURS.toMillis(5); final List<SingularityPendingTaskId> pendingTaskIds = taskManager.getPendingTaskIds(); if (pendingTaskIds.get(0).getRequestId().equals(requestEST.getId())) { nextRunEST = pendingTaskIds.get(0).getNextRunAt(); nextRunGMT = pendingTaskIds.get(1).getNextRunAt();
@Test public void testAfterDeployWaitsForScheduledTaskToFinish() { initScheduledRequest(); initFirstDeploy(); SingularityTask firstTask = launchTask(request, firstDeploy, 1, TaskState.TASK_RUNNING); Assert.assertTrue(taskManager.getPendingTasks().isEmpty()); Assert.assertTrue(taskManager.getActiveTaskIds().contains(firstTask.getTaskId())); Assert.assertEquals(1, taskManager.getActiveTaskIds().size()); Assert.assertTrue(taskManager.getCleanupTaskIds().isEmpty()); deploy("nextDeployId"); deployChecker.checkDeploys(); scheduler.drainPendingQueue(); // no second task should be scheduled Assert.assertTrue(taskManager.getPendingTasks().isEmpty()); Assert.assertTrue(taskManager.getActiveTaskIds().contains(firstTask.getTaskId())); Assert.assertEquals(1, taskManager.getActiveTaskIds().size()); Assert.assertTrue(!taskManager.getCleanupTaskIds().isEmpty()); statusUpdate(firstTask, TaskState.TASK_FINISHED); scheduler.drainPendingQueue(); cleaner.drainCleanupQueue(); Assert.assertTrue(!taskManager.getPendingTasks().isEmpty()); Assert.assertTrue(taskManager.getActiveTaskIds().isEmpty()); Assert.assertTrue(taskManager.getCleanupTaskIds().isEmpty()); SingularityPendingTaskId pendingTaskId = taskManager.getPendingTaskIds().get(0); Assert.assertEquals("nextDeployId", pendingTaskId.getDeployId()); Assert.assertEquals(requestId, pendingTaskId.getRequestId()); }
Assert.assertEquals(lowPriorityRequest.getId(), taskManager.getPendingTaskIds().get(0).getRequestId());
Assert.assertEquals(lowPriorityRequest.getId(), pendingTaskId.getRequestId());