public Optional<SingularityRequestWithState> getRequest(String requestId) { return getRequest(requestId, false); }
public Optional<SingularityTaskIdsByStatus> getTaskIdsByStatusForRequest(String requestId) { Optional<SingularityRequestWithState> requestWithState = requestManager.getRequest(requestId); if (!requestWithState.isPresent()) { return Optional.absent(); } return getTaskIdsByStatusForRequest(requestWithState.get()); }
public void checkForAuthorizationByRequestId(String requestId, SingularityUser user, SingularityAuthorizationScope scope) { if (authEnabled) { final Optional<SingularityRequestWithState> maybeRequest = requestManager.getRequest(requestId); if (maybeRequest.isPresent()) { checkForAuthorization(maybeRequest.get().getRequest(), user, scope); } } }
protected SingularityRequestWithState fetchRequestWithState(String requestId, boolean useWebCache, SingularityUser user) { Optional<SingularityRequestWithState> request = requestManager.getRequest(requestId, useWebCache); checkNotFound(request.isPresent(), "Couldn't find request with id %s", requestId); authorizationHelper.checkForAuthorization(request.get().getRequest(), user, SingularityAuthorizationScope.READ); return request.get(); }
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; }
public SingularityRequestParent postRequest(SingularityRequest request, SingularityUser user) { submitRequest(request, requestManager.getRequest(request.getId()), Optional.absent(), Optional.absent(), Optional.absent(), Optional.absent(), user); return fillEntireRequest(fetchRequestWithState(request.getId(), user)); }
public SingularityCreateResult update(SingularityRequest request, long timestamp, Optional<String> user, Optional<String> message) { return save(request, getRequest(request.getId()).get().getState(), RequestHistoryType.UPDATED, timestamp, user, message); }
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 void checkToSendTaskFinishedMail(SingularityTaskId taskId) { Optional<SingularityRequestWithState> requestWithState = requestManager.getRequest(taskId.getRequestId()); Optional<SingularityTaskHistory> taskHistory = taskManager.getTaskHistory(taskId); ShouldSendMailState shouldSendState = shouldSendTaskFinishedMail(taskId, requestWithState, taskHistory); if (shouldSendState == ShouldSendMailState.WAIT) { return; } try { mailer.sendTaskCompletedMail(taskHistory.get(), requestWithState.get().getRequest()); } catch (Throwable t) { LOG.error("While trying to send task completed mail for {}", taskId, t); } finally { SingularityDeleteResult result = taskManager.deleteFinishedTaskMailQueue(taskId); LOG.debug("Task {} mail sent with status {} (delete result {})", taskId, shouldSendState, result); } }
private boolean canRunRequestLbCleanup(SingularityRequestLbCleanup cleanup, List<SingularityTaskId> lbCleanupTasks) { Optional<SingularityRequestWithState> maybeRequestWithState = requestManager.getRequest(cleanup.getRequestId()); if (maybeRequestWithState.isPresent() && SingularityRequestWithState.isActive(maybeRequestWithState)) { LOG.trace("Request is still active, will wait for request lb cleanup"); return false; } for (String taskId : cleanup.getActiveTaskIds()) { if (taskManager.isActiveTask(taskId)) { LOG.trace("Request still has active tasks, will wait for lb request cleanup"); return false; } } for (SingularityTaskId taskId : lbCleanupTasks) { if (taskId.getRequestId().equals(cleanup.getRequestId())) { LOG.trace("Waiting for task lb cleanup to finish before trying request lb cleanup for request {}", cleanup.getRequestId()); return false; } } return true; }
private Optional<String> getRequestGroup(final String requestId, SingularityUser user) { final Optional<SingularityRequestWithState> maybeRequest = requestManager.getRequest(requestId); if (maybeRequest.isPresent()) { authorizationHelper.checkForAuthorization(maybeRequest.get().getRequest(), user, SingularityAuthorizationScope.READ); return maybeRequest.get().getRequest().getGroup(); } else { Optional<SingularityRequestHistory> maybeRequestHistory = requestHistoryHelper.getLastHistory(requestId); if (maybeRequestHistory.isPresent()) { authorizationHelper.checkForAuthorization(maybeRequestHistory.get().getRequest(), user, SingularityAuthorizationScope.READ); return maybeRequestHistory.get().getRequest().getGroup(); } else { // Deleted requests with no history data are searchable, but only by admins since we have no auth information about them authorizationHelper.checkAdminAuthorization(user); return Optional.absent(); } } }
public SingularityAuthorizationHelperTest() { requestManager = mock(RequestManager.class); when(requestManager.getRequest(REQUEST_WITH_NO_GROUP.getId())).thenReturn(Optional.of(new SingularityRequestWithState(REQUEST_WITH_NO_GROUP, RequestState.ACTIVE, 0))); when(requestManager.getRequest(REQUEST_WITH_GROUP_A.getId())).thenReturn(Optional.of(new SingularityRequestWithState(REQUEST_WITH_GROUP_A, RequestState.ACTIVE, 0))); when(requestManager.getRequest(REQUEST_WITH_GROUP_B.getId())).thenReturn(Optional.of(new SingularityRequestWithState(REQUEST_WITH_GROUP_B, RequestState.ACTIVE, 0))); }
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 void checkForAuthorizationByTaskId(String taskId, SingularityUser user, SingularityAuthorizationScope scope) { if (authEnabled) { checkForbidden(user.isAuthenticated(), "Not Authenticated!"); try { final SingularityTaskId taskIdObj = SingularityTaskId.valueOf(taskId); final Optional<SingularityRequestWithState> maybeRequest = requestManager.getRequest(taskIdObj.getRequestId()); if (maybeRequest.isPresent()) { checkForAuthorization(maybeRequest.get().getRequest(), user, scope); } } catch (InvalidSingularityTaskIdException e) { badRequest(e.getMessage()); } } }
@Override protected void checkExpiringObjects() { for (T expiringObject : requestManager.getExpiringObjects(getClazz())) { if (isExpiringDue(expiringObject)) { Optional<SingularityRequestWithState> requestWithState = requestManager.getRequest(expiringObject.getRequestId()); if (!requestWithState.isPresent()) { LOG.warn("Request {} not present, discarding {}", expiringObject.getRequestId(), expiringObject); } else { lock.runWithRequestLock(() -> { handleExpiringObject(expiringObject, requestWithState.get(), getMessage(expiringObject)); }, requestWithState.get().getRequest().getId(), getClazz().getSimpleName()); } requestManager.deleteExpiringObject(getClazz(), expiringObject.getRequestId()); } } } }
@Test public void testNewTaskCheckerRespectsDeployHealthcheckRetries() { initRequest(); final String deployId = "new_task_healthcheck"; HealthcheckOptions options = new HealthcheckOptionsBuilder("http://uri").setMaxRetries(Optional.of(1)).build(); SingularityDeployBuilder db = new SingularityDeployBuilder(requestId, deployId).setHealthcheck(Optional.of(options)); SingularityDeploy deploy = initAndFinishDeploy(request, db, Optional.absent()); SingularityTask task = launchTask(request, deploy, System.currentTimeMillis(), 1, TaskState.TASK_RUNNING); Assert.assertEquals(CheckTaskState.CHECK_IF_HEALTHCHECK_OVERDUE, newTaskChecker.getTaskState(task, requestManager.getRequest(requestId), healthchecker)); Assert.assertTrue(taskManager.getCleanupTaskIds().isEmpty()); taskManager.saveHealthcheckResult(new SingularityTaskHealthcheckResult(Optional.of(503), Optional.of(1000L), System.currentTimeMillis() + 1, Optional.<String> absent(), Optional.<String> absent(), task.getTaskId(), Optional.<Boolean>absent())); Assert.assertEquals(CheckTaskState.CHECK_IF_HEALTHCHECK_OVERDUE, newTaskChecker.getTaskState(task, requestManager.getRequest(requestId), healthchecker)); taskManager.saveHealthcheckResult(new SingularityTaskHealthcheckResult(Optional.of(503), Optional.of(1000L), System.currentTimeMillis() + 1, Optional.<String> absent(), Optional.<String> absent(), task.getTaskId(), Optional.<Boolean>absent())); Assert.assertEquals(CheckTaskState.UNHEALTHY_KILL_TASK, newTaskChecker.getTaskState(task, requestManager.getRequest(requestId), healthchecker)); }
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(); }
@Test public void testCooldownOnlyWhenTasksRapidlyFail() { initRequest(); initFirstDeploy(); configuration.setCooldownAfterFailures(1); SingularityTask firstTask = startTask(firstDeploy); statusUpdate(firstTask, TaskState.TASK_FAILED, Optional.of(System.currentTimeMillis() - TimeUnit.HOURS.toMillis(5))); Assert.assertTrue(requestManager.getRequest(requestId).get().getState() == RequestState.ACTIVE); SingularityTask secondTask = startTask(firstDeploy); statusUpdate(secondTask, TaskState.TASK_FAILED); Assert.assertTrue(requestManager.getRequest(requestId).get().getState() == RequestState.SYSTEM_COOLDOWN); }
@Test public void testFinishedRequestCanBeDeployed() { initScheduledRequest(); initFirstDeploy(); schedule = "*/1 * * * * ? 1995"; // cause it to be pending requestResource.postRequest(request.toBuilder().setQuartzSchedule(Optional.of(schedule)).build(), singularityUser); scheduler.drainPendingQueue(); Assert.assertTrue(requestResource.getActiveRequests(singularityUser, false, false, false, 10, Collections.emptyList()).isEmpty()); Assert.assertTrue(requestManager.getRequest(requestId).get().getState() == RequestState.FINISHED); SingularityDeployBuilder db = new SingularityDeployBuilder(requestId, secondDeployId); initDeploy(db, System.currentTimeMillis()); deployChecker.checkDeploys(); Assert.assertEquals(RequestState.ACTIVE, requestManager.getRequest(requestId).get().getState()); Assert.assertEquals(1, requestManager.getPendingRequests().size()); }
@Test public void testTaskDestroy() { initRequest(); initFirstDeploy(); SingularityTask firstTask = startTask(firstDeploy, 1); SingularityTask secondTask = startTask(firstDeploy, 2); SingularityTask thirdTask = startTask(firstDeploy, 3); taskResource.killTask(secondTask.getTaskId().getId(), Optional.of( new SingularityKillTaskRequest(Optional.of(true), Optional.of("kill -9 bb"), Optional.absent(), Optional.absent(), Optional.absent())), singularityUser); cleaner.drainCleanupQueue(); killKilledTasks(); Assert.assertEquals(2, taskManager.getNumActiveTasks()); System.out.println(requestManager.getCleanupRequests()); Assert.assertEquals(0, requestManager.getCleanupRequests().size()); Assert.assertEquals(RequestState.ACTIVE, requestManager.getRequest(requestId).get().getState()); }