@Override public void onComplete(ConsulResponse<List<Event>> response) { callback.onComplete(ImmutableEventResponse.of(response.getResponse(), response.getIndex())); }
@Override public void onComplete(ConsulResponse<List<Value>> consulResponse) { callback.onComplete( new ConsulResponse<>(getSingleValue(consulResponse.getResponse()), consulResponse.getLastContact(), consulResponse.isKnownLeader(), consulResponse.getIndex())); }
@VisibleForTesting ImmutableMap<K, V> convertToMap(final ConsulResponse<List<V>> response) { if (response == null || response.getResponse() == null || response.getResponse().isEmpty()) { return ImmutableMap.of(); } final ImmutableMap.Builder<K, V> builder = ImmutableMap.builder(); final Set<K> keySet = new HashSet<>(); for (final V v : response.getResponse()) { final K key = keyConversion.apply(v); if (key != null) { if (!keySet.contains(key)) { builder.put(key, v); } else { LOGGER.warn("Duplicate service encountered. May differ by tags. Try using more specific tags? " + key.toString()); } } keySet.add(key); } return builder.build(); }
@Override public void onComplete(ConsulResponse<List<V>> consulResponse) { if (consulResponse.isKnownLeader()) { if (!isRunning()) { return; lastContact.set(consulResponse.getLastContact()); isKnownLeader.set(consulResponse.isKnownLeader()); if ((consulResponse.getResponse() == null || consulResponse.getResponse().isEmpty()) && cacheConfig.getMinimumDurationDelayOnEmptyResult().compareTo(timeToWait) > 0) { timeToWait = cacheConfig.getMinimumDurationDelayOnEmptyResult();
private static Function<ConsulResponse<Value>, String> valueAsString() { return value -> value.getResponse().getValueAsString(UTF_8).orElse(""); }
public static ConsulResponse<Value> awaitChange(KeyValueClient kv, String key, BigInteger index) { while (true) { final ConsulResponse<Value> response = kv.getConsulResponseWithValue(key, ImmutableQueryOptions.builder() .index(index) .wait("5m") .build()) .orElse(null); if (response == null) { LOGGER.debug("Document does not exist: {}", key); return null; } if (index.equals(response.getIndex())) { LOGGER.debug("Long poll timed out, polling again for {}", key); } else { return response; } } }
@Override public void onComplete(ConsulResponse<ResponseBody> consulResponse) { // Note that response.body() and response.body().byteStream() should be closed. // see: https://square.github.io/okhttp/3.x/okhttp/okhttp3/ResponseBody.html try (ResponseBody responseBody = consulResponse.getResponse()) { try (InputStream inputStream = responseBody.byteStream()) { Files.copy(inputStream, destinationFile.toPath(), StandardCopyOption.REPLACE_EXISTING); callback.onResponse(consulResponse.getIndex()); } } catch (IOException e) { callback.onFailure(e); } }
@Override public List<ServiceDefinition> getServices(String name) { List<CatalogService> services = client.get().catalogClient() .getService(name, queryOptions) .getResponse(); List<ServiceHealth> healths = client.get().healthClient() .getAllServiceInstances(name, queryOptions) .getResponse(); return services.stream() .map(service -> newService(name, service, healths)) .collect(Collectors.toList()); }
protected <T> void processConsulResponse(Message message, ConsulResponse<T> response) throws Exception { message.setHeader(ConsulConstants.CONSUL_INDEX, response.getIndex()); message.setHeader(ConsulConstants.CONSUL_LAST_CONTACT, response.getLastContact()); message.setHeader(ConsulConstants.CONSUL_KNOWN_LEADER, response.isKnownLeader()); setBodyAndResult(message, response.getResponse()); }
index = value.getIndex();
/** * Lists events for the Consul agent. * * GET /v1/event/list?name={name} * * @param name Event name to filter. * @param queryOptions The query options to use. * @return A {@link com.orbitz.consul.model.ConsulResponse} object containing * a list of {@link com.orbitz.consul.model.event.Event} objects. */ public EventResponse listEvents(String name, QueryOptions queryOptions) { Map<String, String> query = StringUtils.isNotEmpty(name) ? ImmutableMap.of("name", name) : Collections.emptyMap(); ConsulResponse<List<Event>> response = http.extractConsulResponse(api.listEvents(query)); return ImmutableEventResponse.of(response.getResponse(), response.getIndex()); }
@GET @Timed @Path("/consul/{service}") public List<ServiceHealth> getHealthyServiceInstances(@PathParam("service") String service) { return consul.healthClient().getHealthyServiceInstances(service).getResponse(); }
/** * Returns a {@link ConsulResponse<Value>} for a specific key from the kv store. * Contains the consul response headers along with the configuration value. * * GET /v1/kv/{key} * * @param key The key to retrieve. * @param queryOptions The query options. * @return An {@link Optional} containing the ConsulResponse or {@link Optional#empty()} */ public Optional<ConsulResponse<Value>> getConsulResponseWithValue(String key, QueryOptions queryOptions) { try { ConsulResponse<List<Value>> consulResponse = http.extractConsulResponse(api.getValue(trimLeadingSlash(key), queryOptions.toQuery()), NOT_FOUND_404); Optional<Value> consulValue = getSingleValue(consulResponse.getResponse()); if (consulValue.isPresent()) { ConsulResponse<Value> result = new ConsulResponse<>(consulValue.get(), consulResponse.getLastContact(), consulResponse.isKnownLeader(), consulResponse.getIndex()); return Optional.of(result); } } catch (ConsulException ignored) { if (ignored.getCode() != NOT_FOUND_404) { throw ignored; } } return Optional.empty(); }
public static void awaitRemoval(KeyValueClient kv, String key) { BigInteger index = BigInteger.ZERO; while (true) { final ConsulResponse<Value> response = kv.getConsulResponseWithValue(key, ImmutableQueryOptions.builder() .index(index) .wait("5m") .build()) .orElse(null); if (response == null) { return; } index = response.getIndex(); } }
@Override public void onComplete(ConsulResponse<T> consulResponse) { if (isRunAllowed()) { onResponse(consulResponse.getResponse()); setIndex(consulResponse.getIndex()); watch(); } }
@Override public Collection<ServiceHealth> discover(final Consul consul) { return consul.healthClient().getHealthyServiceInstances(service).getResponse(); } }
@Override public void onComplete(ConsulResponse<Optional<Value>> consulResponse) { if (isRunAllowed()) { Optional<Value> value = consulResponse.getResponse(); if (value.isPresent()) { Optional<String> sid = value.get().getSession(); if (sid.isPresent() && ObjectHelper.isNotEmpty(sid.get())) { // If the key is not held by any session, try acquire a // lock (become leader) LOGGER.debug("Try to take leadership ..."); setLeader(keyValueClient.acquireLock(servicePath, sessionId)); } else if (!sessionId.equals(sid) && leader.get()) { // Looks like I've lost leadership setLeader(false); } } index.set(consulResponse.getIndex()); run(); } }
public synchronized Membership updateGroupMembership() throws ClusterMembershipException { if (panic) { throw new ClusterMembershipException("Already permanently failed a health check."); } final List<ServiceHealth> healthyServices = consul.healthClient().getHealthyServiceInstances(serviceName).getResponse(); final List<String> serviceKeys = healthyServices.stream() .map(ConsulCoordinator::serviceKey) .sorted() .collect(toList()); System.out.println(); serviceKeys.forEach(System.out::println); int i = 1; for (String key : serviceKeys) { if (key.endsWith(serviceUuid)) { return Membership.of(i, serviceKeys.size()); } i++; } throw new ClusterMembershipException("We're not in the list of healthy services." + " Was another connector worker started on this node without specifying a unique service ID?"); }
@Override public void onComplete(ConsulResponse<Optional<Value>> consulResponse) { if (isStarting() || isStarted()) { Optional<Value> value = consulResponse.getResponse(); if (value.isPresent()) { Optional<String> sid = value.get().getSession(); if (!sid.isPresent()) { // If the key is not held by any session, try acquire a // lock (become leader) boolean lock = acquireLock(); LOGGER.debug("Try to acquire lock on path '{}' with id '{}', result '{}'", path, sessionId.get(), lock); localMember.setMaster(lock); } else { boolean master = sid.get().equals(sessionId.get()); if (!master) { LOGGER.debug("Path {} is held by session {}, local session is {}", path, sid.get(), sessionId.get()); } localMember.setMaster(sid.get().equals(sessionId.get())); } } index.set(consulResponse.getIndex()); watch(); } }