@Override public String toString() { return getId(); } }
public void deleteKilledTask(SingularityTaskId killedTaskId) { if (!active) { LOG.warn("deleteKilledTask {}, but not active", killedTaskId.getId()); return; } killedTasks.remove(killedTaskId); }
public List<String> getActiveTaskIdsAsStrings() { List<SingularityTaskId> localActiveTaskIds = getActiveTaskIds(); List<String> strings = new ArrayList<>(localActiveTaskIds.size()); for (SingularityTaskId taskId : localActiveTaskIds) { strings.add(taskId.getId()); } return strings; }
public void addKilledTask(SingularityKilledTaskIdRecord killedTask) { if (!active) { LOG.warn("addKilledTask {}, but not active", killedTask.getTaskId().getId()); return; } killedTasks.put(killedTask.getTaskId(), killedTask); }
private String fillInTaskIdValues(String string, SingularityOfferHolder offerHolder, SingularityTaskId taskId) { if (!Strings.isNullOrEmpty(string)) { string = string.replace("${TASK_REQUEST_ID}", taskId.getRequestId()) .replace("${TASK_DEPLOY_ID}", taskId.getDeployId()) .replace("${TASK_STARTED_AT}", Long.toString(taskId.getStartedAt())) .replace("${TASK_INSTANCE_NO}", Integer.toString(taskId.getInstanceNo())) .replace("${TASK_HOST}", offerHolder.getHostname()) .replace("${TASK_RACK_ID}", offerHolder.getRackId()) .replace("${TASK_ID}", taskId.getId()); } return string; }
public List<SingularityTaskId> filterActiveTaskIds(List<SingularityTaskId> taskIds) { if (leaderCache.active()) { return leaderCache.exists(taskIds); } final List<String> paths = Lists.newArrayListWithCapacity(taskIds.size()); for (SingularityTaskId taskId : taskIds) { paths.add(getActivePath(taskId.getId())); } return exists("filterActiveTaskIds", paths, taskIdTranscoder); }
private void cleanupRequestIfNoRemainingTasks(SingularityTaskCleanup cleanupTask, List<String> taskIdsForDeletedRequest, boolean isRequestDeleting) { String requestId = cleanupTask.getTaskId().getRequestId(); taskIdsForDeletedRequest.remove(cleanupTask.getTaskId().getId()); if (taskIdsForDeletedRequest.isEmpty() && isRequestDeleting) { LOG.warn("All tasks for requestId {} are now killed, re-enqueueing request cleanup", requestId); requestManager.createCleanupRequest( new SingularityRequestCleanup( cleanupTask.getUser(), RequestCleanupType.DELETING, System.currentTimeMillis(), Optional.of(Boolean.TRUE), cleanupTask.getRemoveFromLoadBalancer(), requestId, Optional.absent(), Optional.absent(), cleanupTask.getMessage(), Optional.absent(), Optional.absent())); } }
public List<SingularityTaskId> filterInactiveTaskIds(List<SingularityTaskId> taskIds) { if (leaderCache.active()) { return leaderCache.getInactiveTaskIds(taskIds); } final Map<String, SingularityTaskId> pathsMap = Maps.newHashMap(); for (SingularityTaskId taskId : taskIds) { pathsMap.put(getActivePath(taskId.getId()), taskId); } return notExists("filterInactiveTaskIds", pathsMap); }
public void checkHealthcheck(SingularityTask task) { if (!taskIdToHealthcheck.containsKey(task.getTaskId().getId())) { LOG.info("Enqueueing expected healthcheck for task {}", task.getTaskId()); Optional<SingularityTaskHealthcheckResult> lastHealthcheck = taskManager.getLastHealthcheck(task.getTaskId()); enqueueHealthcheck(task, false, true, !lastHealthcheck.isPresent()); } }
protected Optional<SingularityTaskHistory> getTaskHistory(SingularityTaskId taskId, SingularityUser user) { authorizationHelper.checkForAuthorizationByRequestId(taskId.getRequestId(), user, SingularityAuthorizationScope.READ); Optional<SingularityTaskHistory> history = taskManager.getTaskHistory(taskId); if (!history.isPresent()) { history = historyManager.getTaskHistory(taskId.getId()); } return history; }
private boolean isLongRunning(SingularityTaskId task) { Optional<SingularityRequestWithState> request = requestManager.getRequest(task.getRequestId()); if (request.isPresent()) { return request.get().getRequest().getRequestType().isLongRunning(); } LOG.warn("Couldn't find request id {} for task {}", task.getRequestId(), task.getId()); return false; }
private Set<String> getRunningTaskIds() { final String slaveId = mesosClient.getSlaveState(mesosClient.getSlaveUri(hostname)).getId(); final Collection<SingularityTask> activeTasks = singularityClient.getActiveTasksOnSlave(slaveId); final Set<String> runningTaskIds = Sets.newHashSet(); for (SingularityTask task : activeTasks) { runningTaskIds.add(task.getTaskId().getId()); } return runningTaskIds; }
protected void saveLoadBalancerState(BaragonRequestState brs, SingularityTaskId taskId, LoadBalancerRequestType lbrt) { final LoadBalancerRequestId lbri = new LoadBalancerRequestId(taskId.getId(), lbrt, Optional.<Integer> absent()); SingularityLoadBalancerUpdate update = new SingularityLoadBalancerUpdate(brs, lbri, Optional.<String> absent(), System.currentTimeMillis(), LoadBalancerMethod.CHECK_STATE, null); taskManager.saveLoadBalancerState(taskId, lbrt, update); }
public SingularityCreateResult saveTaskCleanup(SingularityTaskCleanup cleanup) { saveTaskHistoryUpdate(cleanup); leaderCache.saveTaskCleanup(cleanup); return save(getCleanupPath(cleanup.getTaskId().getId()), cleanup, taskCleanupTranscoder); }
public SingularityCreateResult createTaskCleanup(SingularityTaskCleanup cleanup) { leaderCache.createTaskCleanupIfNotExists(cleanup); final SingularityCreateResult result = create(getCleanupPath(cleanup.getTaskId().getId()), cleanup, taskCleanupTranscoder); if (result == SingularityCreateResult.CREATED) { saveTaskHistoryUpdate(cleanup); } return result; }
@Test public void testTaskKill() { initRequest(); initFirstDeploy(); SingularityTask firstTask = startTask(firstDeploy); taskResource.killTask(firstTask.getTaskId().getId(), Optional.absent(), singularityUser); cleaner.drainCleanupQueue(); killKilledTasks(); Assert.assertEquals(0, taskManager.getNumCleanupTasks()); Assert.assertEquals(0, taskManager.getNumActiveTasks()); }