@Override public String apply(@Nonnull SingularityRequestWithState input) { return input.getRequest().getId(); } });
public void cacheRequests(List<SingularityRequestWithState> requests) { requestsMissMeter.mark(); Map<String, SingularityRequestWithState> newRequests = new HashMap<>(requests.size()); for (SingularityRequestWithState request : requests) { newRequests.put(request.getRequest().getId(), request); } cachedRequests = newRequests; lastRequestsCache = System.currentTimeMillis(); }
public void putRequest(SingularityRequestWithState requestWithState) { if (!active) { LOG.warn("putRequest {}, but not active", requestWithState.getRequest().getId()); return; } requests.put(requestWithState.getRequest().getId(), requestWithState); }
@Override public String apply(@Nonnull SingularityRequestWithState input) { return input.getRequest().getId(); } });
public static SingularityPendingRequestParent minimalFromRequestWithState(SingularityRequestWithState requestWithState, SingularityPendingRequest pendingRequest) { return new SingularityPendingRequestParent(requestWithState.getRequest(), requestWithState.getState(), Optional.absent(), Optional.absent(), Optional.absent(), Optional.absent(), pendingRequest, Optional.absent(), Optional.absent(), Optional.absent(), Optional.absent(), Optional.absent(), Optional.absent(), Optional.absent()); }
private boolean checkCooldown(SingularityRequestWithState cooldownRequest) { if (shouldExitCooldown(cooldownRequest)) { requestManager.exitCooldown(cooldownRequest.getRequest(), System.currentTimeMillis(), Optional.<String> absent(), Optional.<String> absent()); return true; } return false; }
private SingularityRequest updatedRequest(Optional<SingularityPendingDeploy> maybePendingDeploy, SingularityPendingRequest pendingRequest, SingularityRequestWithState currentRequest) { if (maybePendingDeploy.isPresent() && pendingRequest.getDeployId().equals(maybePendingDeploy.get().getDeployMarker().getDeployId())) { return maybePendingDeploy.get().getUpdatedRequest().or(currentRequest.getRequest()); } else { return currentRequest.getRequest(); } } }
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); } } }
private List<SingularityRequestWithState> filterAutorized(List<SingularityRequestWithState> requests, final SingularityAuthorizationScope scope, SingularityUser user) { authorizationHelper.checkUserInRequiredGroups(user); if (!authorizationHelper.hasAdminAuthorization(user)) { return requests.stream() .filter((parent) -> authorizationHelper.isAuthorizedForRequest(parent.getRequest(), user, scope)) .collect(Collectors.toList()); } return requests; }
@Override protected void handleExpiringObject(SingularityExpiringPause expiringObject, SingularityRequestWithState requestWithState, String message) { if (requestWithState.getState() != RequestState.PAUSED) { LOG.warn("Discarding {} because request {} is in state {}", expiringObject, requestWithState.getRequest().getId(), requestWithState.getState()); return; } LOG.info("Unpausing request {} because of {}", requestWithState.getRequest().getId(), expiringObject); requestHelper.unpause(requestWithState.getRequest(), expiringObject.getUser(), Optional.of(message), Optional.absent()); }
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 void submitScaleRequest(SingularityRequestWithState oldRequestWithState, Integer newRequestedInstances) { SingularityRequest oldRequest = oldRequestWithState.getRequest(); SingularityRequest newRequest = oldRequest.toBuilder().setInstances(Optional.of((newRequestedInstances))).build(); Optional<SingularityRequestHistory.RequestHistoryType> historyType = Optional.of(SingularityRequestHistory.RequestHistoryType.SCALED); Optional<String> message = Optional.of(String.format("Auto scale number of instances to spread to all %d available slaves", newRequestedInstances)); requestHelper.updateRequest(newRequest, Optional.of(oldRequest), oldRequestWithState.getState(), historyType, Optional.<String>absent(), oldRequest.getSkipHealthchecks(), message, Optional.<SingularityBounceRequest>absent()); }
@GET @Path("/ids") @Operation(summary = "Retrieve the list of active request ids") public List<String> getActiveRequests( @Parameter(hidden = true) @Auth SingularityUser user, @Parameter(description = "Fetched a cached version of this data to limit expensive operations") @QueryParam("useWebCache") Boolean useWebCache) { return filterAutorized(Lists.newArrayList(requestManager.getRequests(useWebCache(useWebCache))), SingularityAuthorizationScope.READ, user) .stream() .map((r) -> r.getRequest().getId()) .collect(Collectors.toList()); }
private void updatePossiblyUnderProvisionedAndOverProvisionedIds(SingularityRequestWithState requestWithState, Map<String, Long> numInstances, List<String> overProvisionedRequestIds, Set<String> possiblyUnderProvisionedRequestIds) { if (requestWithState.getState().isRunnable() && requestWithState.getRequest().isAlwaysRunning()) { SingularityRequest request = requestWithState.getRequest(); final int expectedInstances = request.getInstancesSafe(); final Long numActualInstances = numInstances.get(request.getId()); if (numActualInstances == null || numActualInstances < expectedInstances) { possiblyUnderProvisionedRequestIds.add(request.getId()); } else if (numActualInstances > expectedInstances) { overProvisionedRequestIds.add(request.getId()); } } }
@Override protected void handleExpiringObject(SingularityExpiringSkipHealthchecks expiringObject, SingularityRequestWithState requestWithState, String message) { final SingularityRequest oldRequest = requestWithState.getRequest(); final SingularityRequest newRequest = oldRequest.toBuilder().setSkipHealthchecks(expiringObject.getRevertToSkipHealthchecks()).build(); try { requestHelper.updateRequest(newRequest, Optional.of(oldRequest), requestWithState.getState(), Optional.<RequestHistoryType>absent(), expiringObject.getUser(), Optional.<Boolean>absent(), Optional.of(message), Optional.<SingularityBounceRequest>absent()); } catch (WebApplicationException wae) { LOG.error("While trying to apply {} for {}", expiringObject, expiringObject.getRequestId(), wae); } } }
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 checkForRepeatedFailures(Optional<SingularityRequestWithState> requestWithState, SingularityTaskId taskId) { taskManager.markUnhealthyKill(taskId); if (requestWithState.isPresent() && taskManager.getNumUnhealthyKills(taskId.getRequestId()) > configuration.getCooldownAfterFailures()) { mailer.sendReplacementTasksFailingMail(requestWithState.get().getRequest()); } }
public SingularityRequestParent skipHealthchecks(String requestId, SingularitySkipHealthchecksRequest skipHealthchecksRequest, SingularityUser user) { SingularityRequestWithState oldRequestWithState = fetchRequestWithState(requestId, user); SingularityRequest oldRequest = oldRequestWithState.getRequest(); SingularityRequest newRequest = oldRequest.toBuilder().setSkipHealthchecks(skipHealthchecksRequest.getSkipHealthchecks()).build(); submitRequest(newRequest, Optional.of(oldRequestWithState), Optional.absent(), Optional.absent(), skipHealthchecksRequest.getMessage(), Optional.absent(), user); if (skipHealthchecksRequest.getDurationMillis().isPresent()) { requestManager.saveExpiringObject(new SingularityExpiringSkipHealthchecks(requestId, user.getEmail(), System.currentTimeMillis(), skipHealthchecksRequest, oldRequest.getSkipHealthchecks(), skipHealthchecksRequest.getActionId().or(UUID.randomUUID().toString()))); } return fillEntireRequest(fetchRequestWithState(requestId, user)); }
private SingularityRequestParent updateAuthorizedGroups(SingularityUser user, String requestId, SingularityUpdateGroupsRequest updateGroupsRequest) { SingularityRequestWithState oldRequestWithState = fetchRequestWithState(requestId, user); authorizationHelper.checkForAuthorization(oldRequestWithState.getRequest(), user, SingularityAuthorizationScope.WRITE); SingularityRequest newRequest = oldRequestWithState.getRequest().toBuilder() .setGroup(updateGroupsRequest.getGroup()) .setReadWriteGroups(Optional.of(updateGroupsRequest.getReadWriteGroups())) .setReadOnlyGroups(Optional.of(updateGroupsRequest.getReadOnlyGroups())) .build(); submitRequest(newRequest, Optional.of(oldRequestWithState), Optional.of(RequestHistoryType.UPDATED), Optional.absent(), updateGroupsRequest.getMessage(), Optional.absent(), user); return fillEntireRequest(fetchRequestWithState(requestId, user)); }
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; }