com.orbitz.consul.model.health.ServiceHealth Java Examples

/**
 * Build a {@link Server} instance from a Consul {@link ServiceHealth} instance. If the service
 * has an address defined, use that as the server host, otherwise default to using the node
 * address.
 *
 * @param service Consul service health record
 * @return Ribbon Server instance
 */
private Server buildServer(final ServiceHealth service) {
  @Nullable final String scheme = service.getService().getMeta().get("scheme");
  final int port = service.getService().getPort();

  final String address;
  if (!Strings.isNullOrEmpty(service.getService().getAddress())) {
    address = service.getService().getAddress();
  } else {
    address = service.getNode().getAddress();
  }

  final Server server = new Server(scheme, address, port);
  server.setZone(service.getNode().getDatacenter().orElse(Server.UNKNOWN_ZONE));
  server.setReadyToServe(true);

  return server;
}
 

@Override
public void notify(Map<ServiceHealthKey, ServiceHealth> newValues) {
    Set<Registration> previousEntries = topologyManager.registrationsForService(this.name);

    Set<Registration> newEntries = newValues.values().stream()
            .map(e -> new Registration("consul",
                                       this.name,
                                       e.getService().getAddress(),
                                       e.getService().getPort())
                    .addTags(e.getService().getTags())
            )
            .collect(Collectors.toSet());

    previousEntries.stream()
            .filter(e -> !newEntries.contains(e))
            .forEach(e -> {
                this.topologyManager.unregister(e);
            });

    newEntries.stream()
            .filter(e -> !previousEntries.contains(e))
            .forEach(e -> {
                this.topologyManager.register(e);
            });
}
 

ArrayList<String> getBootStrapServersFromConsul(String consulServer, String consulKafkaServicename) {
    ArrayList<String> bootstrapServers = null;
    LOG.info("CONSUL: Consul server used: [" + consulServer + "]");
    LOG.info("CONSUL: Consul service retrieved: [" + consulKafkaServicename + "]");
    try {
        Consul consul = Consul.builder().withUrl(consulServer).build();
        HealthClient healthClient = consul.healthClient();

        // discover only "passing" nodes
        List<ServiceHealth> nodes = healthClient.getHealthyServiceInstances(consulKafkaServicename).getResponse();
        for (ServiceHealth kafkaNode : nodes) {
            String address = kafkaNode.getService().getAddress();
            String port = kafkaNode.getService().getPort() + "";
            if (bootstrapServers == null) {
                bootstrapServers = new ArrayList<String>();
            }
            bootstrapServers.add(address + ":" + port);
        }
    } catch (Exception e){
        LOG.error("CONSUL: " + e.toString());
    }
    LOG.info("CONSUL: Kafka services found through Consul server: " + (bootstrapServers==null?"None available":bootstrapServers.toString()));
    return bootstrapServers;
}
 

@Override
public void notify(Map<HostAndPort, ServiceHealth> newValues) {
    Set<Registration> previousEntries = topologyManager.registrationsForService(this.name);

    Set<Registration> newEntries = newValues.values().stream()
            .map(e -> new Registration("consul",
                    this.name,
                    e.getService().getAddress(),
                    e.getService().getPort())
                    .addTags(e.getService().getTags())
            )
            .collect(Collectors.toSet());

    previousEntries.stream()
            .filter(e -> !newEntries.contains(e))
            .forEach(e -> {
                this.topologyManager.unregister(e);
            });

    newEntries.stream()
            .filter(e -> !previousEntries.contains(e))
            .forEach(e -> {
                this.topologyManager.register(e);
            });
}
 

@Override
public List<RemoteInstance> queryRemoteNodes() {
    HealthClient healthClient = client.healthClient();

    // Discover only "passing" nodes
    List<ServiceHealth> nodes = healthClient.getHealthyServiceInstances(serviceName).getResponse();

    List<RemoteInstance> remoteInstances = new ArrayList<>();
    if (CollectionUtils.isNotEmpty(nodes)) {
        nodes.forEach(node -> {
            if (!Strings.isNullOrEmpty(node.getService().getAddress())) {
                Address address = new Address(node.getService().getAddress(), node.getService().getPort(), false);
                if (address.equals(selfAddress)) {
                    address.setSelf(true);
                }
                remoteInstances.add(new RemoteInstance(address));
            }
        });
    }
    return remoteInstances;
}
 

@Override
public String getValue(String propertyName) {
    if (propertyName.startsWith(CONFIG_DISCOVERY_SERVICE_PREFIX)) {
        Consul consul = ConsulClient.build();
        String[] serviceNameAndProp = propertyName.split("\\.");
        if (serviceNameAndProp.length == 4) {
            String serviceName = serviceNameAndProp[2];
            String serviceProp = serviceNameAndProp[3];
            if (serviceProp.equals("url")) {
                // propertyName is "discovery.service.NAME.url"
                // result is a url that doesn't end with / and optionally includes context root
                List<ServiceHealth> services = consul.healthClient()
                        .getHealthyServiceInstances(serviceName).getResponse();
                if (!services.isEmpty()) {
                    int randomIndex = new Random().nextInt(services.size());
                    Service selectedService = services.get(randomIndex).getService();
                    String contextRoot = selectedService.getMeta().getOrDefault(ConsulClient.KEY_CTX_ROOT, "");
                    if ( !contextRoot.isEmpty() && !contextRoot.startsWith("/")) {
                        contextRoot = "/" + contextRoot;
                    }
                    StringBuilder resultBuilder = new StringBuilder();
                    resultBuilder = resultBuilder.append("http://").append(selectedService.getAddress())
                            .append(":").append(selectedService.getPort())
                            .append(contextRoot);
                    return resultBuilder.toString();
                }
            }
        }
    }
    return null;
}
 

@Override
public List<RpcURL> getUrls(String registryHost,int registryPort) {
    List<RpcURL> urls= Lists.newArrayList();
    Consul consul = this.buildConsul(registryHost,registryPort);
    HealthClient client = consul.healthClient();
    String name = CONSUL_NAME;
    ConsulResponse object= client.getAllServiceInstances(name);
    List<ImmutableServiceHealth> serviceHealths=(List<ImmutableServiceHealth>)object.getResponse();
    for(ImmutableServiceHealth serviceHealth:serviceHealths){
        RpcURL url=new RpcURL();
        url.setHost(serviceHealth.getService().getAddress());
        url.setPort(serviceHealth.getService().getPort());
        urls.add(url);
    }

    try {
        ServiceHealthCache serviceHealthCache = ServiceHealthCache.newCache(client, name);
        serviceHealthCache.addListener(new ConsulCache.Listener<ServiceHealthKey, ServiceHealth>() {
            @Override
            public void notify(Map<ServiceHealthKey, ServiceHealth> map) {
                logger.info("serviceHealthCache.addListener notify");
                RpcClientInvokerCache.clear();

            }
        });
        serviceHealthCache.start();
    } catch (Exception e) {
        logger.info("serviceHealthCache.start error:",e);
    }
    return urls;
}
 

private ServiceHealth mockSelfService() {
    ServiceHealth serviceHealth = mock(ServiceHealth.class);
    Service service = mock(Service.class);

    when(service.getAddress()).thenReturn(selfRemoteAddress.getHost());
    when(service.getPort()).thenReturn(selfRemoteAddress.getPort());

    when(serviceHealth.getService()).thenReturn(service);

    return serviceHealth;
}
 

private ServiceHealth mockNotSelfService() {
    ServiceHealth serviceHealth = mock(ServiceHealth.class);
    Service service = mock(Service.class);

    when(service.getAddress()).thenReturn(remoteAddress.getHost());
    when(service.getPort()).thenReturn(remoteAddress.getPort());

    when(serviceHealth.getService()).thenReturn(service);

    return serviceHealth;
}
 

private List<ServiceHealth> mockHealth() {
    List<ServiceHealth> result = new LinkedList<>();
    result.add(mockSelfService());
    result.add(mockNotSelfService());
    result.add(mockNullServiceAddress());
    return result;
}
 

@Test
public void queryRemoteNodesWithNullSelf() {
    List<ServiceHealth> serviceHealths = mockHealth();
    when(consulResponse.getResponse()).thenReturn(serviceHealths);
    List<RemoteInstance> remoteInstances = coordinator.queryRemoteNodes();
    // filter empty address
    assertEquals(2, remoteInstances.size());
}
 

@Test
public void queryRemoteNodes() {
    registerSelfRemote();
    List<ServiceHealth> serviceHealths = mockHealth();
    when(consulResponse.getResponse()).thenReturn(serviceHealths);
    List<RemoteInstance> remoteInstances = coordinator.queryRemoteNodes();
    assertEquals(2, remoteInstances.size());

    RemoteInstance selfInstance = remoteInstances.get(0);
    velidate(selfRemoteAddress, selfInstance);

    RemoteInstance notSelfInstance = remoteInstances.get(1);
    velidate(remoteAddress, notSelfInstance);
}
 

@Test
public void findAvailableServicesTest() {
    injects();
    final List<ServiceHealth> nodes = healthClient.getHealthyServiceInstances("DataService").getResponse();
    Assert.assertTrue(CollectionUtils.isEmpty(nodes));
}
 

@Override
public Iterable<DiscoveryNode> discoverNodes() {
	
	List<DiscoveryNode> toReturn = new ArrayList<DiscoveryNode>();
	
	try {
		// discover healthy nodes only? (and its NOT the first invocation...)
		if (this.consulHealthyOnly && discoverNodesInvoked) {
			
			List<ServiceHealth> nodes = consulHealthClient.getHealthyServiceInstances(consulServiceName, ConsulUtility.getAclToken(this.consulAclToken)).getResponse();
			
			for (ServiceHealth node : nodes) {
				toReturn.add(new SimpleDiscoveryNode(
								new Address(node.getService().getAddress(),node.getService().getPort())));
				getLogger().info("Discovered healthy node: " + node.getService().getAddress()+":"+node.getService().getPort());
			}
			
		// discover all services, regardless of health or this is the first invocation
		} else {
			
			ConsulResponse<List<CatalogService>> response = this.consulCatalogClient.getService(consulServiceName, ConsulUtility.getAclToken(this.consulAclToken));
			
			for (CatalogService service : response.getResponse()) {
				
				String discoveredAddress = null;
				String rawServiceAddress = service.getServiceAddress();
				String rawAddress = service.getAddress();
				
				if (rawServiceAddress != null && !rawServiceAddress.trim().isEmpty()) {
				    discoveredAddress = rawServiceAddress;
					
				} else if (rawAddress != null && !rawAddress.trim().isEmpty()) {
				    getLogger().warning("discoverNodes() ServiceAddress was null/blank! " +
						     "for service: " + service.getServiceName() + 
						     " falling back to Address value");
				    discoveredAddress = rawAddress;
					
				} else {
				    getLogger().warning("discoverNodes() could not discover an address, " +
						     "both ServiceAddress and Address were null/blank! " +
						     "for service: " + service.getServiceName());
				}
				
				toReturn.add(new SimpleDiscoveryNode(
						new Address(discoveredAddress, service.getServicePort())));
				getLogger().info("Discovered healthy node: " + discoveredAddress+":"+service.getServicePort());
			}
		}
		
	} catch(Exception e) {
		getLogger().severe("discoverNodes() unexpected error: " + e.getMessage(),e);
	}

	// flag we were invoked
	discoverNodesInvoked = true;
	
	return toReturn;
}
 

@Override
public Collection<ServiceHealth> discover(final Consul consul) {
  return consul.healthClient().getHealthyServiceInstances(service).getResponse();
}
 

@GET
@Timed
@Path("/consul/{service}")
public List<ServiceHealth> getHealthyServiceInstances(@PathParam("service") String service) {
  return consul.healthClient().getHealthyServiceInstances(service).getResponse();
}
 

private ServiceHealth mockNullServiceAddress() {
    ServiceHealth serviceHealth = mock(ServiceHealth.class);
    Service service = mock(Service.class);

    when(serviceHealth.getService()).thenReturn(service);

    when(service.getAddress()).thenReturn("");

    return serviceHealth;
}
 

/**
 * Converts a list of {@link ServiceHealth} objects into {@link Server} objects
 *
 * @param services list of healthy service instances
 * @return list of server instances
 */
private List<Server> buildServerList(final Collection<ServiceHealth> services) {
  return services.stream().map(this::buildServer).collect(Collectors.toList());
}
 

Collection<ServiceHealth> discover(Consul consul);