congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
io.airlift.discovery.client
Code IndexAdd Tabnine to your IDE (free)

How to use io.airlift.discovery.client

Best Java code snippets using io.airlift.discovery.client (Showing top 20 results out of 315)

origin: prestodb/presto

  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);
  }
}
origin: prestodb/presto

  private static boolean isCoordinator(ServiceDescriptor service)
  {
    return Boolean.parseBoolean(service.getProperties().get("coordinator"));
  }
}
origin: prestodb/presto

  @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);
origin: prestodb/presto

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();
}
origin: prestodb/presto

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());
origin: prestodb/presto

  @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);
  }
});
origin: prestodb/presto

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);
origin: prestodb/presto

    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);
origin: prestodb/presto

@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);
origin: prestodb/presto

@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);
}
origin: prestodb/presto

modules.add(
    new NodeModule(),
    new DiscoveryModule(),
    new HttpServerModule(),
    new JsonModule(),
  injector.getInstance(EventListenerManager.class).loadConfiguredEventListener();
  injector.getInstance(Announcer.class).start();
origin: prestodb/presto

@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();
}
origin: prestodb/presto

  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();
  }
}
origin: prestodb/presto

@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();
}
origin: prestodb/presto

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");
}
origin: prestodb/presto

public final AllNodes refreshNodes()
{
  serviceSelectorManager.forceRefresh();
  nodeManager.refreshNodes();
  return nodeManager.getAllNodes();
}
origin: prestodb/presto

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;
}
origin: prestodb/presto

  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);
  }
}
origin: prestodb/presto

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;
}
origin: prestodb/presto

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

Most used classes

  • DiscoveryBinder
  • ServiceDescriptor
  • ServiceAnnouncement$ServiceAnnouncementBuilder
  • ServiceAnnouncement
  • Announcer
  • DiscoveryModule,
  • ServiceType,
  • TestingDiscoveryModule,
  • ServiceTypes,
  • ServiceDescriptor$ServiceDescriptorBuilder,
  • ServiceDescriptorsRepresentation,
  • ServiceDescriptors,
  • ServiceInventory,
  • AnnouncementHttpServerInfo,
  • ServiceSelectorManager,
  • Announcement,
  • CachingServiceSelector,
  • DiscoveryClientConfig,
  • DiscoveryLookupClient
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now