private void checkS3() { checkNotFound(s3Services.isS3ConfigPresent(), "S3 configuration was absent"); checkNotFound(configuration.isPresent(), "S3 configuration was absent"); }
protected SingularityTaskHistory getTaskHistoryRequired(SingularityTaskId taskId, SingularityUser user) { Optional<SingularityTaskHistory> history = getTaskHistory(taskId, user); checkNotFound(history.isPresent(), "No history for task %s", taskId); return history.get(); }
protected SingularityDeployHistory getDeployHistory(String requestId, String deployId, SingularityUser user) { authorizationHelper.checkForAuthorizationByRequestId(requestId, user, SingularityAuthorizationScope.READ); Optional<SingularityDeployHistory> deployHistory = deployManager.getDeployHistory(requestId, deployId, true); if (deployHistory.isPresent()) { return deployHistory.get(); } deployHistory = historyManager.getDeployHistory(requestId, deployId); checkNotFound(deployHistory.isPresent(), "Deploy history for request %s and deploy %s not found", requestId, deployId); return deployHistory.get(); }
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(); }
@GET @Path("/cluster/utilization") @Operation(summary = "GET a summary of utilization for all slaves and requests in the mesos cluster") public SingularityClusterUtilization getClusterUtilization(@Parameter(hidden = true) @Auth SingularityUser user) { //authorizationHelper.checkAdminAuthorization(user); Needed for ui pages outside single request WebExceptions.checkNotFound(usageManager.getClusterUtilization().isPresent(), "No cluster utilization has been saved yet"); return usageManager.getClusterUtilization().get(); }
private <T extends SingularityExpiringRequestActionParent<?>> SingularityRequestParent deleteExpiringObject(Class<T> clazz, String requestId, SingularityUser user) { SingularityRequestWithState requestWithState = fetchRequestWithState(requestId, user); SingularityDeleteResult deleteResult = requestManager.deleteExpiringObject(clazz, requestId); WebExceptions.checkNotFound(deleteResult == SingularityDeleteResult.DELETED, "%s didn't have an expiring %s request", clazz.getSimpleName(), requestId); return fillEntireRequest(requestWithState); }
private SingularityTask checkActiveTask(String taskId, SingularityAuthorizationScope scope, SingularityUser user) { SingularityTaskId taskIdObj = getTaskIdFromStr(taskId); Optional<SingularityTask> task = taskManager.getTask(taskIdObj); checkNotFound(task.isPresent() && taskManager.isActiveTask(taskId), "No active task with id %s", taskId); if (task.isPresent()) { authorizationHelper.checkForAuthorizationByRequestId(task.get().getTaskId().getRequestId(), user, scope); } return task.get(); }
@GET @PropertyFiltering @Path("/scheduled/task/{pendingTaskId}") @Operation(summary = "Retrieve information about a pending task") public SingularityTaskRequest getPendingTask( @Parameter(hidden = true) @Auth SingularityUser user, @Parameter(description = "The unique id of the pending task") @PathParam("pendingTaskId") String pendingTaskIdStr) { Optional<SingularityPendingTask> pendingTask = taskManager.getPendingTask(getPendingTaskIdFromStr(pendingTaskIdStr)); checkNotFound(pendingTask.isPresent(), "Couldn't find %s", pendingTaskIdStr); List<SingularityTaskRequest> taskRequestList = taskRequestManager.getTaskRequests(Collections.singletonList(pendingTask.get())); checkNotFound(!taskRequestList.isEmpty(), "Couldn't find: " + pendingTaskIdStr); authorizationHelper.checkForAuthorization(taskRequestList.get(0).getRequest(), user, SingularityAuthorizationScope.READ); return taskRequestList.get(0); }
protected void remove(String objectId, SingularityUser user) { authorizationHelper.checkAdminAuthorization(user); checkNotFound(manager.deleteObject(objectId) == SingularityDeleteResult.DELETED, "Couldn't find dead %s with id %s", getObjectTypeString(), objectId); }
private Collection<String> getS3PrefixesForRequest(S3Configuration s3Configuration, String requestId, Optional<Long> startArg, Optional<Long> endArg, String group) { Optional<SingularityRequestHistory> firstHistory = requestHistoryHelper.getFirstHistory(requestId); checkNotFound(firstHistory.isPresent(), "No request history found for %s", requestId); long start = firstHistory.get().getCreatedAt(); if (startArg.isPresent()) { start = Math.max(startArg.get(), start); } Optional<SingularityRequestHistory> lastHistory = requestHistoryHelper.getLastHistory(requestId); long end = System.currentTimeMillis(); if (lastHistory.isPresent() && (lastHistory.get().getEventType() == RequestHistoryType.DELETED || lastHistory.get().getEventType() == RequestHistoryType.PAUSED)) { end = lastHistory.get().getCreatedAt() + TimeUnit.DAYS.toMillis(1); } if (endArg.isPresent()) { end = Math.min(endArg.get(), end); } Collection<String> prefixes = SingularityS3FormatHelper.getS3KeyPrefixes(s3Configuration.getS3KeyFormat(), requestId, start, end, group); for (SingularityS3UploaderFile additionalFile : s3Configuration.getS3UploaderAdditionalFiles()) { if (additionalFile.getS3UploaderKeyPattern().isPresent() && !additionalFile.getS3UploaderKeyPattern().get().equals(s3Configuration.getS3KeyFormat())) { prefixes.addAll(SingularityS3FormatHelper.getS3KeyPrefixes(additionalFile.getS3UploaderKeyPattern().get(), requestId, start, end, group)); } } LOG.trace("Request {} got S3 prefixes {} for start {}, end {}", requestId, prefixes, start, end); return prefixes; }
@GET @Path("/slaves/{slaveId}/tasks/current") @Operation(summary = "Retrieve a list of resource usages for active tasks on a particular slave") public List<SingularityTaskCurrentUsageWithId> getSlaveCurrentTaskUsage( @Parameter(hidden = true) @Auth SingularityUser user, @Parameter(required = true, description = "The slave to retrieve task usages for") @PathParam("slaveId") String slaveId) { authorizationHelper.checkAdminAuthorization(user); Optional<SingularitySlave> slave = slaveManager.getObject(slaveId); WebExceptions.checkNotFound(slave.isPresent(), "No slave found with id %s", slaveId); List<SingularityTask> tasksOnSlave = taskManager.getTasksOnSlave(taskManager.getActiveTaskIds(), slave.get()); List<SingularityTaskId> taskIds = new ArrayList<>(tasksOnSlave.size()); for (SingularityTask task : tasksOnSlave) { taskIds.add(task.getTaskId()); } return usageManager.getTaskCurrentUsages(taskIds); }
final Optional<MesosFileChunkObject> maybeChunk = sandboxManager.read(slaveHostname, fullPath, offset, length); checkNotFound(maybeChunk.isPresent(), "File %s does not exist for task ID %s", fullPath, taskId);
@GET @Path("/active/slave/{slaveId}") @Operation( summary = "Retrieve list of active tasks on a specific slave", responses = { @ApiResponse(responseCode = "404", description = "A slave with the specified id was not found") } ) public List<SingularityTask> getTasksForSlave( @Parameter(hidden = true) @Auth SingularityUser user, @Parameter(description = "The mesos slave id to retrieve tasks for") @PathParam("slaveId") String slaveId, @Parameter(description = "Use the cached version of this data to limit expensive api calls") @QueryParam("useWebCache") Boolean useWebCache) { Optional<SingularitySlave> maybeSlave = slaveManager.getObject(slaveId); checkNotFound(maybeSlave.isPresent(), "Couldn't find a slave in any state with id %s", slaveId); return authorizationHelper.filterByAuthorizedRequests(user, taskManager.getTasksOnSlave(taskManager.getActiveTaskIds(useWebCache(useWebCache)), maybeSlave.get()), SingularityTransformHelpers.TASK_TO_REQUEST_ID, SingularityAuthorizationScope.READ); }
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; }
WebExceptions.checkNotFound(taskManager.taskExistsInZk(taskIdObj), "Task %s not found in ZooKeeper (can not save metadata to tasks which have been persisted", taskIdObj);
protected SingularityTaskHistory getTaskHistoryRequired(SingularityTaskId taskId, SingularityUser user) { Optional<SingularityTaskHistory> history = getTaskHistory(taskId, user); checkNotFound(history.isPresent(), "No history for task %s", taskId); return history.get(); }
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(); }
@GET @Path("/cluster/utilization") @Operation(summary = "GET a summary of utilization for all slaves and requests in the mesos cluster") public SingularityClusterUtilization getClusterUtilization(@Parameter(hidden = true) @Auth SingularityUser user) { //authorizationHelper.checkAdminAuthorization(user); Needed for ui pages outside single request WebExceptions.checkNotFound(usageManager.getClusterUtilization().isPresent(), "No cluster utilization has been saved yet"); return usageManager.getClusterUtilization().get(); }
private SingularityTask checkActiveTask(String taskId, SingularityAuthorizationScope scope, SingularityUser user) { SingularityTaskId taskIdObj = getTaskIdFromStr(taskId); Optional<SingularityTask> task = taskManager.getTask(taskIdObj); checkNotFound(task.isPresent() && taskManager.isActiveTask(taskId), "No active task with id %s", taskId); if (task.isPresent()) { authorizationHelper.checkForAuthorizationByRequestId(task.get().getTaskId().getRequestId(), user, scope); } return task.get(); }
protected void remove(String objectId, SingularityUser user) { authorizationHelper.checkAdminAuthorization(user); checkNotFound(manager.deleteObject(objectId) == SingularityDeleteResult.DELETED, "Couldn't find dead %s with id %s", getObjectTypeString(), objectId); }