@Override public SingularityClient get() { Preconditions.checkState(contextPath != null, "contextPath null"); Preconditions.checkState(!hosts.isEmpty(), "no hosts provided"); return new SingularityClient(contextPath, httpClient, hosts, credentials, ssl); }
public SingularityRequestParent createDeployForSingularityRequest(String requestId, SingularityDeploy pendingDeploy, Optional<Boolean> deployUnpause, Optional<String> message) { return createDeployForSingularityRequest(requestId, pendingDeploy, deployUnpause, message, Optional.absent()); }
private HttpResponse executeRequest(Function<String, String> hostToUri, String type, Optional<?> body, Method method, Optional<Map<String, Object>> queryParams) { final long start = System.currentTimeMillis(); HttpResponse response = executeRequest(hostToUri, method, body, queryParams.or(Collections.emptyMap())); checkResponse(type, response); LOG.info("Successfully {}ed {} in {}ms", method, type, System.currentTimeMillis() - start); return response; }
/** * Remove a {@link SingularityRequestGroup} * * @param requestGroupId * The request group ID to search for */ public void deleteRequestGroup(String requestGroupId) { final Function<String, String> requestUri = (host) -> String.format(REQUEST_GROUP_FORMAT, getApiBase(host), requestGroupId); delete(requestUri, "request group", requestGroupId); }
public void clearInactiveSlave(String host) { final Function<String, String> requestUri = (singularityHost) -> String.format(INACTIVE_SLAVES_FORMAT, getApiBase(host)); Map<String, Object> params = Collections.singletonMap("host", host); deleteWithParams(requestUri, "clearInactiveSlave", host, Optional.absent(), Optional.of(params), Optional.absent()); }
singularityClient.createOrUpdateSingularityRequest(request); final Optional<SingularityRequestParent> requestParent = singularityClient.getSingularityRequest(REQUEST_ID); assertTrue(requestParent.isPresent()); assertEquals(request, requestParent.get().getRequest()); .build(); singularityClient.createDeployForSingularityRequest(REQUEST_ID, deploy, Optional.<Boolean>absent(), Optional.<String> absent()); final Optional<SingularityDeployHistory> deployHistory = singularityClient.getHistoryForRequestDeploy(REQUEST_ID, deployId); if (deployHistory.isPresent() && deployHistory.get().getDeployResult().isPresent()) { deployState = Optional.fromNullable(deployHistory.get().getDeployResult().get().getDeployState());
public Optional<SingularityTaskReconciliationStatistics> getTaskReconciliationStatistics() { final Function<String, String> uri = (host) -> String.format(TASK_RECONCILIATION_FORMAT, getApiBase(host)); LOG.info("Fetch task reconciliation statistics from {}", uri); final long start = System.currentTimeMillis(); HttpResponse response = executeRequest(uri, Method.GET, Optional.absent(), Collections.emptyMap()); if (response.getStatusCode() == 404) { return Optional.absent(); } checkResponse("task reconciliation statistics", response); LOG.info("Got task reconciliation statistics in {}ms", System.currentTimeMillis() - start); return Optional.of(response.getAs(SingularityTaskReconciliationStatistics.class)); }
public SingularityRequestParent cancelPendingDeployForSingularityRequest(String requestId, String deployId) { final Function<String, String> requestUri = (host) -> String.format(DELETE_DEPLOY_FORMAT, getApiBase(host), deployId, requestId); SingularityRequestParent singularityRequestParent = delete(requestUri, "pending deploy", new SingularityDeployKey(requestId, deployId).getId(), Optional.absent(), Optional.of(SingularityRequestParent.class)).get(); return getAndLogRequestAndDeployStatus(singularityRequestParent); }
private <T> Optional<T> getSingleWithParams(Function<String, String> hostToUrl, String type, String id, Optional<Map<String, Object>> queryParams, TypeReference<T> typeReference) { final long start = System.currentTimeMillis(); HttpResponse response = executeGetSingleWithParams(hostToUrl, type, id, queryParams); if (response.getStatusCode() == 404) { return Optional.absent(); } checkResponse(type, response); LOG.info("Got {} {} in {}ms", type, id, System.currentTimeMillis() - start); return Optional.fromNullable(response.getAs(typeReference)); }
private HttpResponse executeRequest(Function<String, String> hostToUri, Method method, Optional<?> body, Map<String, ?> queryParams) { HttpRequest.Builder request = HttpRequest.newBuilder().setMethod(method); if (body.isPresent()) { request.setBody(body.get()); } addQueryParams(request, queryParams); addCredentials(request); List<String> hosts = new ArrayList<>(hostsProvider.get()); request .setRetryStrategy(RetryStrategy.NEVER_RETRY) .setMaxRetries(1); try { return httpResponseRetryer.call(() -> { if (hosts.isEmpty()) { // We've tried everything we started with. Look again. hosts.addAll(hostsProvider.get()); } int selection = random.nextInt(hosts.size()); String host = hosts.get(selection); String url = hostToUri.apply(host); hosts.remove(selection); LOG.info("Making {} request to {}", method, url); request.setUrl(url); return httpClient.execute(request.build()); }); } catch (ExecutionException | RetryException exn) { throw new SingularityClientException("Failed request to Singularity", exn); } }
private void delete(Function<String, String> hostToUrl, String type, String id) { delete(hostToUrl, type, id, Optional.absent()); }
private <T> Optional<T> delete(Function<String, String> hostToUrl, String type, String id, Optional<?> body, Optional<Class<T>> clazz) { return deleteWithParams(hostToUrl, type, id, body, Optional.absent(), clazz); }
@Deprecated public void decomissionSlave(String slaveId) { decommissionSlave(slaveId, Optional.absent()); }
@Deprecated public void decomissionRack(String rackId) { decommissionRack(rackId, Optional.absent()); }
public void deleteRack(String rackId) { final Function<String, String> requestUri = (host) -> String.format(RACKS_DELETE_FORMAT, getApiBase(host), rackId); delete(requestUri, "dead rack", rackId); }
public SingularityState getState(Optional<Boolean> skipCache, Optional<Boolean> includeRequestIds) { final Function<String, String> uri = (host) -> String.format(STATE_FORMAT, getApiBase(host)); LOG.info("Fetching state from {}", uri); final long start = System.currentTimeMillis(); Map<String, Boolean> queryParams = new HashMap<>(); if (skipCache.isPresent()) { queryParams.put("skipCache", skipCache.get()); } if (includeRequestIds.isPresent()) { queryParams.put("includeRequestIds", includeRequestIds.get()); } HttpResponse response = executeRequest(uri, Method.GET, Optional.absent(), queryParams); checkResponse("state", response); LOG.info("Got state in {}ms", System.currentTimeMillis() - start); return response.getAs(SingularityState.class); }
public Optional<SingularityDeleteResult> deleteWebhook(String webhookId) { final Function<String, String> requestUri = (host) -> String.format(WEBHOOKS_DELETE_FORMAT, getApiBase(host)); Builder<String, Object> queryParamBuider = ImmutableMap.<String, Object>builder().put("webhookId", webhookId); return deleteWithParams(requestUri, String.format("webhook with id %s", webhookId), webhookId, Optional.absent(), Optional.of(queryParamBuider.build()), Optional.of(SingularityDeleteResult.class)); }
private <T> Optional<T> getSingleWithParams(Function<String, String> hostToUrl, String type, String id, Optional<Map<String, Object>> queryParams, Class<T> clazz) { final long start = System.currentTimeMillis(); HttpResponse response = executeGetSingleWithParams(hostToUrl, type, id, queryParams); if (response.getStatusCode() == 404) { return Optional.absent(); } checkResponse(type, response); LOG.info("Got {} {} in {}ms", type, id, System.currentTimeMillis() - start); return Optional.fromNullable(response.getAs(clazz)); }
private <T> void delete(Function<String, String> hostToUrl, String type, String id, Optional<?> body) { delete(hostToUrl, type, id, body, Optional.<Class<T>>absent()); }
public void deleteSlave(String slaveId) { final Function<String, String> requestUri = (host) -> String.format(SLAVES_DELETE_FORMAT, getApiBase(host), slaveId); delete(requestUri, "deleting slave", slaveId); }