How to use io.airlift.discovery.client

  private static ServiceAnnouncement getPrestoAnnouncement(Set<ServiceAnnouncement> announcements)
  {
    for (ServiceAnnouncement announcement : announcements) {
      if (announcement.getType().equals("presto")) {
        return announcement;
      }
    }
    throw new RuntimeException("Presto announcement not found: " + announcements);
  }
}

  private static boolean isCoordinator(ServiceDescriptor service)
  {
    return Boolean.parseBoolean(service.getProperties().get("coordinator"));
  }
}

  @Override
  public void run()
  {
    try {
      ping();
      updateState();
    }
    catch (Throwable e) {
      // ignore to avoid getting unscheduled
      log.warn(e, "Error pinging service %s (%s)", service.getId(), uri);
    }
  }
}, heartbeat.toMillis(), heartbeat.toMillis(), TimeUnit.MILLISECONDS);

private static void updateConnectorIdAnnouncement(Announcer announcer, ConnectorId connectorId, InternalNodeManager nodeManager)
{
  //
  // This code was copied from PrestoServer, and is a hack that should be removed when the connectorId property is removed
  //
  // get existing announcement
  ServiceAnnouncement announcement = getPrestoAnnouncement(announcer.getServiceAnnouncements());
  // update connectorIds property
  Map<String, String> properties = new LinkedHashMap<>(announcement.getProperties());
  String property = nullToEmpty(properties.get("connectorIds"));
  Set<String> connectorIds = new LinkedHashSet<>(Splitter.on(',').trimResults().omitEmptyStrings().splitToList(property));
  connectorIds.add(connectorId.toString());
  properties.put("connectorIds", Joiner.on(',').join(connectorIds));
  // update announcement
  announcer.removeServiceAnnouncement(announcement.getId());
  announcer.addServiceAnnouncement(serviceAnnouncement(announcement.getType()).addProperties(properties).build());
  announcer.forceAnnounce();
  nodeManager.refreshNodes();
}

private static void updateConnectorIds(Announcer announcer, CatalogManager metadata, ServerConfig serverConfig, NodeSchedulerConfig schedulerConfig)
  ServiceAnnouncement announcement = getPrestoAnnouncement(announcer.getServiceAnnouncements());
  String property = nullToEmpty(announcement.getProperties().get("connectorIds"));
  List<String> values = Splitter.on(',').trimResults().omitEmptyStrings().splitToList(property);
  Set<String> connectorIds = new LinkedHashSet<>(values);
  ServiceAnnouncementBuilder builder = serviceAnnouncement(announcement.getType());
  for (Map.Entry<String, String> entry : announcement.getProperties().entrySet()) {
    if (!entry.getKey().equals("connectorIds")) {
      builder.addProperty(entry.getKey(), entry.getValue());
  builder.addProperty("connectorIds", Joiner.on(',').join(connectorIds));
  announcer.removeServiceAnnouncement(announcement.getId());
  announcer.addServiceAnnouncement(builder.build());

  @Override
  public void configure(Binder binder)
  {
    configBinder(binder).bindConfig(InternalCommunicationConfig.class);
    configBinder(binder).bindConfig(QueryManagerConfig.class);
    discoveryBinder(binder).bindSelector("presto");
    discoveryBinder(binder).bindHttpAnnouncement("presto");
    // Jersey with jetty 9 requires at least one resource
    // todo add a dummy resource to airlift jaxrs in this case
    jaxrsBinder(binder).bind(FooResource.class);
  }
});

Set<ServiceDescriptor> services = serviceSelector.selectAllServices().stream()
    .filter(service -> !failureDetector.getFailed().contains(service))
    .collect(toImmutableSet());
  boolean coordinator = isCoordinator(service);
  if (uri != null && nodeVersion != null) {
    PrestoNode node = new PrestoNode(service.getNodeId(), uri, nodeVersion, coordinator);
    NodeState nodeState = getNodeState(node);
        String connectorIds = service.getProperties().get("connectorIds");
        if (connectorIds != null) {
          connectorIds = connectorIds.toLowerCase(ENGLISH);

    new TestingNodeModule(),
    new TestingJmxModule(),
    new TestingDiscoveryModule(),
    new TestingHttpServerModule(),
    new TraceTokenModule(),
    .initialize();
ServiceSelector selector = injector.getInstance(Key.get(ServiceSelector.class, serviceType("presto")));
assertEquals(selector.selectAllServices().size(), 1);

@VisibleForTesting
void updateMonitoredServices()
  Set<ServiceDescriptor> online = selector.selectAllServices().stream()
      .filter(descriptor -> !nodeInfo.getNodeId().equals(descriptor.getNodeId()))
      .collect(toImmutableSet());
        .filter(task -> !onlineIds.contains(task.getService().getId()))
        .forEach(MonitoringTask::disable);
        .filter(service -> !tasks.keySet().contains(service.getId()))
        .collect(toImmutableSet());
        tasks.put(service.getId(), new MonitoringTask(service, uri));
        .filter(task -> onlineIds.contains(task.getService().getId()))
        .forEach(MonitoringTask::enable);

@BeforeMethod
public void setup()
{
  testHttpClient = new TestingHttpClient(input -> new TestingResponse(OK, ArrayListMultimap.create(), ACTIVE.name().getBytes()));
  expectedVersion = new NodeVersion("1");
  coordinator = new PrestoNode(UUID.randomUUID().toString(), URI.create("https://192.0.2.8"), expectedVersion, false);
  activeNodes = ImmutableList.of(
      new PrestoNode(nodeInfo.getNodeId(), URI.create("http://192.0.1.1"), expectedVersion, false),
      new PrestoNode(UUID.randomUUID().toString(), URI.create("http://192.0.2.1:8080"), expectedVersion, false),
      new PrestoNode(UUID.randomUUID().toString(), URI.create("http://192.0.2.3"), expectedVersion, false),
      coordinator);
  inactiveNodes = ImmutableList.of(
      new PrestoNode(UUID.randomUUID().toString(), URI.create("https://192.0.3.9"), NodeVersion.UNKNOWN, false),
      new PrestoNode(UUID.randomUUID().toString(), URI.create("https://192.0.4.9"), new NodeVersion("2"), false));
  List<ServiceDescriptor> descriptors = new ArrayList<>();
  for (PrestoNode node : Iterables.concat(activeNodes, inactiveNodes)) {
    descriptors.add(serviceDescriptor("presto")
        .setNodeId(node.getNodeIdentifier())
        .addProperty("http", node.getHttpUri().toString())
        .addProperty("node_version", node.getNodeVersion().toString())
        .addProperty("coordinator", String.valueOf(node.equals(coordinator)))
        .build());
  }
  selector = new StaticServiceSelector(descriptors);
}

modules.add(
    new NodeModule(),
    new DiscoveryModule(),
    new HttpServerModule(),
    new JsonModule(),
  injector.getInstance(EventListenerManager.class).loadConfiguredEventListener();
  injector.getInstance(Announcer.class).start();

@Inject
public DiscoveryNodeManager(
    @ServiceType("presto") ServiceSelector serviceSelector,
    NodeInfo nodeInfo,
    FailureDetector failureDetector,
    NodeVersion expectedNodeVersion,
    @ForNodeManager HttpClient httpClient,
    InternalCommunicationConfig internalCommunicationConfig)
{
  this.serviceSelector = requireNonNull(serviceSelector, "serviceSelector is null");
  this.failureDetector = requireNonNull(failureDetector, "failureDetector is null");
  this.expectedNodeVersion = requireNonNull(expectedNodeVersion, "expectedNodeVersion is null");
  this.httpClient = requireNonNull(httpClient, "httpClient is null");
  this.nodeStateUpdateExecutor = newSingleThreadScheduledExecutor(threadsNamed("node-state-poller-%s"));
  this.nodeStateEventExecutor = newCachedThreadPool(threadsNamed("node-state-events-%s"));
  this.httpsRequired = internalCommunicationConfig.isHttpsRequired();
  this.currentNode = findCurrentNode(
      serviceSelector.selectAllServices(),
      requireNonNull(nodeInfo, "nodeInfo is null").getNodeId(),
      expectedNodeVersion,
      httpsRequired);
  refreshNodesInternal();
}

  private List<URI> getAllNodes(URI server)
  {
    Request request = prepareGet().setUri(uriBuilderFrom(server).replacePath("/v1/service/presto").build()).build();
    JsonResponseHandler<ServiceDescriptorsRepresentation> responseHandler = createJsonResponseHandler(jsonCodec(ServiceDescriptorsRepresentation.class));
    ServiceDescriptorsRepresentation serviceDescriptors = httpClient.execute(request, responseHandler);

    ImmutableList.Builder<URI> addresses = ImmutableList.builder();
    for (ServiceDescriptor serviceDescriptor : serviceDescriptors.getServiceDescriptors()) {
      String httpUri = serviceDescriptor.getProperties().get("http");
      if (httpUri != null) {
        addresses.add(URI.create(httpUri));
      }
    }
    return addresses.build();
  }
}

@Inject
public HeartbeatFailureDetector(
    @ServiceType("presto") ServiceSelector selector,
    @ForFailureDetector HttpClient httpClient,
    FailureDetectorConfig failureDetectorConfig,
    NodeInfo nodeInfo,
    InternalCommunicationConfig internalCommunicationConfig)
{
  requireNonNull(selector, "selector is null");
  requireNonNull(httpClient, "httpClient is null");
  requireNonNull(nodeInfo, "nodeInfo is null");
  requireNonNull(failureDetectorConfig, "config is null");
  checkArgument(failureDetectorConfig.getHeartbeatInterval().toMillis() >= 1, "heartbeat interval must be >= 1ms");
  this.selector = selector;
  this.httpClient = httpClient;
  this.nodeInfo = nodeInfo;
  this.failureRatioThreshold = failureDetectorConfig.getFailureRatioThreshold();
  this.heartbeat = failureDetectorConfig.getHeartbeatInterval();
  this.warmupInterval = failureDetectorConfig.getWarmupInterval();
  this.gcGraceInterval = failureDetectorConfig.getExpirationGraceInterval();
  this.isEnabled = failureDetectorConfig.isEnabled();
  this.httpsRequired = internalCommunicationConfig.isHttpsRequired();
}

private static PrestoNode findCurrentNode(List<ServiceDescriptor> allServices, String currentNodeId, NodeVersion expectedNodeVersion, boolean httpsRequired)
{
  for (ServiceDescriptor service : allServices) {
    URI uri = getHttpUri(service, httpsRequired);
    NodeVersion nodeVersion = getNodeVersion(service);
    if (uri != null && nodeVersion != null) {
      PrestoNode node = new PrestoNode(service.getNodeId(), uri, nodeVersion, isCoordinator(service));
      if (node.getNodeIdentifier().equals(currentNodeId)) {
        checkState(
            node.getNodeVersion().equals(expectedNodeVersion),
            "INVARIANT: current node version (%s) should be equal to %s",
            node.getNodeVersion(),
            expectedNodeVersion);
        return node;
      }
    }
  }
  throw new IllegalStateException("INVARIANT: current node not returned from service selector");
}

public final AllNodes refreshNodes()
{
  serviceSelectorManager.forceRefresh();
  nodeManager.refreshNodes();
  return nodeManager.getAllNodes();
}

private static URI getHttpUri(ServiceDescriptor descriptor, boolean httpsRequired)
{
  String url = descriptor.getProperties().get(httpsRequired ? "https" : "http");
  if (url != null) {
    try {
      return new URI(url);
    }
    catch (URISyntaxException ignored) {
    }
  }
  return null;
}

  private static ServiceAnnouncement getPrestoAnnouncement(Set<ServiceAnnouncement> announcements)
  {
    for (ServiceAnnouncement announcement : announcements) {
      if (announcement.getType().equals("presto")) {
        return announcement;
      }
    }
    throw new IllegalArgumentException("Presto announcement not found: " + announcements);
  }
}

private URI getHttpUri(ServiceDescriptor descriptor)
{
  String url = descriptor.getProperties().get(httpsRequired ? "https" : "http");
  if (url != null) {
    try {
      return new URI(url);
    }
    catch (URISyntaxException ignored) {
    }
  }
  return null;
}

private static NodeVersion getNodeVersion(ServiceDescriptor descriptor)
{
  String nodeVersion = descriptor.getProperties().get("node_version");
  return nodeVersion == null ? null : new NodeVersion(nodeVersion);
}