com.hazelcast.spi.discovery.DiscoveryNode Java Examples

@Test
public void resolveWithPodLabelWhenNodeWithPodLabel() {
    // given
    List<Endpoint> endpoints = createEndpoints(2);
    given(client.endpointsByPodLabel(POD_LABEL, POD_LABEL_VALUE)).willReturn(endpoints);

    KubernetesApiEndpointResolver sut = new KubernetesApiEndpointResolver(LOGGER, null, 0, null, null,
            POD_LABEL, POD_LABEL_VALUE, null, client);

    // when
    List<DiscoveryNode> nodes = sut.resolve();

    // then
    assertEquals(1, nodes.size());
    assertEquals(2, nodes.get(0).getPrivateAddress().getPort());
}
 

@Test
public void resolveWithServiceLabelWhenNodeWithServiceLabel() {
    // given
    List<Endpoint> endpoints = createEndpoints(2);
    given(client.endpointsByServiceLabel(SERVICE_LABEL, SERVICE_LABEL_VALUE)).willReturn(endpoints);

    KubernetesApiEndpointResolver sut = new KubernetesApiEndpointResolver(LOGGER, null, 0, SERVICE_LABEL, SERVICE_LABEL_VALUE,
            null, null, null, client);

    // when
    List<DiscoveryNode> nodes = sut.resolve();

    // then
    assertEquals(1, nodes.size());
    assertEquals(2, nodes.get(0).getPrivateAddress().getPort());
}
 

@Override 
public Address determineMyLocalAddress(DiscoveryNode localDiscoveryNode, Map<String, Object> registratorConfig) {
	
	Address myLocalAddress = localDiscoveryNode.getPrivateAddress();
	 
	Object usePublicAddress = (Object)registratorConfig.get(CONFIG_PROP_PREFER_PUBLIC_ADDRESS);
	if (usePublicAddress != null && usePublicAddress instanceof Boolean && (Boolean)usePublicAddress) {
		logger.info("Registrator config property: " + CONFIG_PROP_PREFER_PUBLIC_ADDRESS +":"+usePublicAddress + " attempting to use it...");
		Address publicAddress = localDiscoveryNode.getPublicAddress();
		if (publicAddress != null) {
			myLocalAddress = publicAddress;
		}
	}
	
	return myLocalAddress;
}
 

@Override
public void init(
		String consulHost, 
		Integer consulPort, 
		String consulServiceName, 
		String[] consulServiceTags, 
		String consulAclToken,  
		boolean consulSslEnabled,
		String	consulSslServerCertFilePath,
		String consulSslServerCertBase64,
		boolean consulServerHostnameVerify,
		DiscoveryNode localDiscoveryNode,
		Map<String, Object> registratorConfig, 
		ILogger logger) {

}
 

private List<DiscoveryNode> getSimpleDiscoveryNodes(List<Endpoint> endpoints) {
    List<DiscoveryNode> discoveredNodes = new ArrayList<DiscoveryNode>();
    for (Endpoint address : endpoints) {
        addAddress(discoveredNodes, address);
    }
    return discoveredNodes;
}
 

@Test
public void resolveWithServiceNameWhenNotReadyAddressesAndNotReadyDisabled() {
    // given
    List<Endpoint> endpoints = createNotReadyEndpoints(2);
    given(client.endpointsByName(SERVICE_NAME)).willReturn(endpoints);

    KubernetesApiEndpointResolver sut = new KubernetesApiEndpointResolver(LOGGER, SERVICE_NAME, 0, null, null, null, null, null,
            client);

    // when
    List<DiscoveryNode> nodes = sut.resolve();

    // then
    assertEquals(0, nodes.size());
}
 

@Test
public void resolveWithServiceNameWhenNotReadyAddressesAndNotReadyEnabled() {
    // given
    List<Endpoint> endpoints = createNotReadyEndpoints(2);
    given(client.endpointsByName(SERVICE_NAME)).willReturn(endpoints);

    KubernetesApiEndpointResolver sut = new KubernetesApiEndpointResolver(LOGGER, SERVICE_NAME, 0, null, null,
            null, null, RESOLVE_NOT_READY_ADDRESSES, client);

    // when
    List<DiscoveryNode> nodes = sut.resolve();

    // then
    assertEquals(1, nodes.size());
}
 

private void resolveWithServiceNameWhenNodeInNamespace(final int port, final int expectedPort) {
    // given
    List<Endpoint> endpoints = createEndpoints(1);
    given(client.endpointsByName(SERVICE_NAME)).willReturn(endpoints);

    KubernetesApiEndpointResolver sut = new KubernetesApiEndpointResolver(LOGGER, SERVICE_NAME, port, null, null, null, null, null,
            client);

    // when
    List<DiscoveryNode> nodes = sut.resolve();

    // then
    assertEquals(1, nodes.size());
    assertEquals(expectedPort, nodes.get(0).getPrivateAddress().getPort());
}
 

@Test
public void resolveWhenNodeInFound() {
    // given
    List<Endpoint> endpoints = Collections.<Endpoint>emptyList();
    given(client.endpoints()).willReturn(endpoints);

    KubernetesApiEndpointResolver sut = new KubernetesApiEndpointResolver(LOGGER, null, 0, null, null, null, null, null, client);

    // when
    List<DiscoveryNode> nodes = sut.resolve();

    // then
    assertEquals(0, nodes.size());
}
 

@Test
public void resolveNotFound()
        throws Exception {
    // given
    when(servers.hasMore()).thenReturn(false);
    DnsEndpointResolver dnsEndpointResolver = new DnsEndpointResolver(LOGGER, SERVICE_DNS, UNSET_PORT, dirContext);

    // when
    List<DiscoveryNode> result = dnsEndpointResolver.resolve();

    // then
    assertEquals(0, result.size());
}
 

@Test
public void resolveException()
        throws Exception {
    // given
    when(dirContext.getAttributes(SERVICE_DNS, new String[]{"SRV"})).thenThrow(new NameNotFoundException());
    DnsEndpointResolver dnsEndpointResolver = new DnsEndpointResolver(LOGGER, SERVICE_DNS, UNSET_PORT, dirContext);

    // when
    List<DiscoveryNode> result = dnsEndpointResolver.resolve();

    // then
    assertEquals(0, result.size());
}
 

@Test
public void resolveCustomPort() {
    // given
    DnsEndpointResolver dnsEndpointResolver = new DnsEndpointResolver(LOGGER, SERVICE_DNS, CUSTOM_PORT, dirContext);

    // when
    List<DiscoveryNode> result = dnsEndpointResolver.resolve();

    // then

    Set<?> resultAddresses = setOf(result.get(0).getPrivateAddress().getHost(), result.get(1).getPrivateAddress().getHost());
    Set<?> resultPorts = setOf(result.get(0).getPrivateAddress().getPort(), result.get(1).getPrivateAddress().getPort());
    assertEquals(setOf(IP_SERVER_1, IP_SERVER_2), resultAddresses);
    assertEquals(setOf(CUSTOM_PORT), resultPorts);
}
 

@Test
public void resolve() {
    // given
    DnsEndpointResolver dnsEndpointResolver = new DnsEndpointResolver(LOGGER, SERVICE_DNS, UNSET_PORT, dirContext);

    // when
    List<DiscoveryNode> result = dnsEndpointResolver.resolve();

    // then

    Set<?> resultAddresses = setOf(result.get(0).getPrivateAddress().getHost(), result.get(1).getPrivateAddress().getHost());
    Set<?> resultPorts = setOf(result.get(0).getPrivateAddress().getPort(), result.get(1).getPrivateAddress().getPort());
    assertEquals(setOf(IP_SERVER_1, IP_SERVER_2), resultAddresses);
    assertEquals(setOf(DEFAULT_PORT), resultPorts);
}
 

private void addAddress(List<DiscoveryNode> discoveredNodes, Endpoint endpoint) {
    if (Boolean.TRUE.equals(resolveNotReadyAddresses) || endpoint.isReady()) {
        Address privateAddress = createAddress(endpoint.getPrivateAddress());
        Address publicAddress = createAddress(endpoint.getPublicAddress());
        discoveredNodes
                .add(new SimpleDiscoveryNode(privateAddress, publicAddress, endpoint.getAdditionalProperties()));
        if (logger.isFinestEnabled()) {
            logger.finest(String.format("Found node service with addresses (private, public): %s, %s ", privateAddress,
                    publicAddress));
        }
    }
}
 

@Override
List<DiscoveryNode> resolve() {
    if (serviceName != null && !serviceName.isEmpty()) {
        logger.fine("Using service name to discover nodes.");
        return getSimpleDiscoveryNodes(client.endpointsByName(serviceName));
    } else if (serviceLabel != null && !serviceLabel.isEmpty()) {
        logger.fine("Using service label to discover nodes.");
        return getSimpleDiscoveryNodes(client.endpointsByServiceLabel(serviceLabel, serviceLabelValue));
    } else if (podLabel != null && !podLabel.isEmpty()) {
        logger.fine("Using pod label to discover nodes.");
        return getSimpleDiscoveryNodes(client.endpointsByPodLabel(podLabel, podLabelValue));
    }
    return getSimpleDiscoveryNodes(client.endpoints());
}
 

@Override
public DiscoveryStrategy newDiscoveryStrategy(
        DiscoveryNode discoveryNode,
        ILogger logger,
        //Implementing DiscoveryStrategyFactory method with a raw type
        @SuppressWarnings("rawtypes") Map<String, Comparable> properties
) {
    return
            new DockerDNSRRDiscoveryStrategy(
                    logger,
                    properties
            );
}
 

@Override
public Iterable<DiscoveryNode> discoverNodes() {

    List<DiscoveryNode> toReturn = new ArrayList<>();

    try {

        Set<DiscoveredContainer> discoveredContainers = this.swarmDiscoveryUtil.discoverContainers();

        /**
         * We have all the containers, convert to DiscoveryNodes and return...
         */
        getLogger().info("discoverNodes() DiscoveredContainers[" + discoveredContainers.size() + "]: " +
                Arrays.toString(discoveredContainers.toArray(new DiscoveredContainer[]{})));

        for (DiscoveredContainer container : discoveredContainers) {
            toReturn.add(new SimpleDiscoveryNode(
                    new Address(container.getIp(),
                            swarmDiscoveryUtil.getHazelcastPeerPort())));
        }

        return toReturn;

    } catch (Exception e) {
        getLogger().severe("discoverNodes() unexpected error: " + e.getMessage(), e);
    }

    return toReturn;
}
 

@Bean
public DiscoveryServiceProvider discoveryServiceProvider(DiscoveryClient discoveryClient) {
    return new DiscoveryServiceProvider() {

        @Override
        public DiscoveryService newDiscoveryService(DiscoveryServiceSettings settings) {
            return new DiscoveryService() {

                @Override
                public void destroy() {
                }

                @Override
                public Map<String, Object> discoverLocalMetadata() {
                    return Collections.emptyMap();
                }

                @Override
                public Iterable<DiscoveryNode> discoverNodes() {
                    List<DiscoveryNode> nodes = new ArrayList<>();
                    discoveryClient.getInstances(clusterName).forEach((ServiceInstance serviceInstance) -> {
                        try {
                            String host = serviceInstance.getMetadata().get(HAZELCAST_HOST_KEY);
                            String port = serviceInstance.getMetadata().get(HAZELCAST_PORT_KEY);
                            String version = serviceInstance.getMetadata().get(HAZELCAST_VERSION_KEY);
                            if (host != null && port != null && StringUtils.equals(version, hazelcastVersion)) {
                                Address address = new Address(host, Integer.parseInt(port));
                                DiscoveryNode discoveryNode = new SimpleDiscoveryNode(address);
                                nodes.add(discoveryNode);
                            }
                        } catch (Exception e) {
                            logger.error("discoverNodes()", e);
                        }
                    });
                    return nodes;
                }

                @Override
                public void start() {
                }

            };
        }

    };
}
 

public DiscoveryStrategy newDiscoveryStrategy(DiscoveryNode discoveryNode, ILogger logger,
                                              Map<String, Comparable> properties) {

    return new HazelcastKubernetesDiscoveryStrategy(logger, properties);
}
 

@Override
public Iterable<DiscoveryNode> discoverNodes() {
    return endpointResolver.resolve();
}
 

@Override
public void init(String consulHost, 
		         Integer consulPort,
		         String consulServiceName,
		         String[] consulTags,
		         String consulAclToken,
		         boolean consulSslEnabled,
				 String	consulSslServerCertFilePath,
				 String consulSslServerCertBase64,
				 boolean consulServerHostnameVerify,
		         DiscoveryNode localDiscoveryNode,
		         Map<String, Object> registratorConfig,
		         ILogger logger) throws Exception {
	
	this.logger = logger;
	this.tags = consulTags;
	this.consulHost = consulHost;
	this.consulPort = consulPort;
	this.consulServiceName = consulServiceName;
	this.consulAclToken = consulAclToken;
	this.registratorConfig = registratorConfig;
	
	try {
		/**
		 * Determine my local address
		 */
		this.myLocalAddress = determineMyLocalAddress(localDiscoveryNode, registratorConfig);
		logger.info("Determined local DiscoveryNode address to use: " + myLocalAddress);
		
		
		//Build our consul client to use. We pass in optional TLS information
		ConsulBuilder builder = ConsulClientBuilder.class.newInstance();
		Consul consul = builder.buildConsul(consulHost, 
											consulPort, 
											consulSslEnabled, 
											consulSslServerCertFilePath, 
											consulSslServerCertBase64, 
											consulServerHostnameVerify,
											consulAclToken);
		
		 
		// build my Consul agent client that we will register with
		this.consulAgentClient =  consul.agentClient();
		
	} catch(Exception e) {
		String msg = "Unexpected error in configuring LocalDiscoveryNodeRegistration: " + e.getMessage();
		logger.severe(msg,e);
		throw new Exception(msg,e);
	}
	
}
 

protected abstract Address determineMyLocalAddress(DiscoveryNode localDiscoveryNode,  
Map<String, Object> registratorConfig) throws Exception;
 

@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;
}
 

public DiscoveryStrategy newDiscoveryStrategy(DiscoveryNode discoveryNode,
											  ILogger logger,
											  Map<String, Comparable> properties ) {

	return new ConsulDiscoveryStrategy( discoveryNode, logger, properties );                                      
}
 

@Override
public Iterable<DiscoveryNode> discoverNodes() {
    LinkedList<DiscoveryNode> discoveryNodes =
            new LinkedList<>();

    //Pull properties
    String servicesCsv = getOrDefault(
            DockerDNSRRDiscoveryConfiguration.SERVICESCSV,
            ""
    );

    //If there are no services configured, no point in doing anything.
    if (
            servicesCsv == null ||
                    servicesCsv.trim().isEmpty()
    ) {
        return discoveryNodes;
    }

    Set<InetAddress> serviceNameResolutions =
            new HashSet<>();
    String[] serviceHostnameAndPort;
    Integer port = 5701;

    //Loop for every service defined in the CSV
    for (String service : servicesCsv.split(",")) {
        if (!service.trim().isEmpty()) {
            //CSV should be composed of hostname:port
            serviceHostnameAndPort = service.split(":");

            //Validate hostname exists
            if (
                    serviceHostnameAndPort[0] == null ||
                            serviceHostnameAndPort[0].trim().isEmpty()
            ) {
                logger.info(
                        "Unable to resolve service hostname " +
                                serviceHostnameAndPort[0] +
                                " Skipping service entry."
                );
                continue;
            }
            //Validate port exists; assume default port if it doesn't
            if (
                    serviceHostnameAndPort.length <= 1 ||
                            serviceHostnameAndPort[1] == null ||
                            serviceHostnameAndPort[1].trim().isEmpty()
            ) {
                port = 5701;
            } else {
                try {
                    port = Integer.valueOf(
                            serviceHostnameAndPort[1]
                    );
                } catch (NumberFormatException nfe) {
                    logger.info(
                            "Unable to parse port " +
                                    serviceHostnameAndPort[1] +
                                    " Skipping service entry."
                    );
                    continue;
                }
            }

            //Resolve service hostname to a set of IP addresses, if any
            serviceNameResolutions =
                    resolveDomainNames(
                            serviceHostnameAndPort[0]
                    );

            //Add all IP addresses for service hostname with the given port.
            for (InetAddress resolution : serviceNameResolutions) {
                discoveryNodes.add(
                        new SimpleDiscoveryNode(
                                new Address(
                                        resolution,
                                        port
                                )
                        )
                );
            }
        }
    }

    return discoveryNodes;
}
 

public DiscoveryStrategy newDiscoveryStrategy(DiscoveryNode discoveryNode,
                                              ILogger logger,
                                              Map<String, Comparable> properties) {

    return new DockerSwarmDiscoveryStrategy(discoveryNode, logger, properties);
}
 

/**
 * Initialize the registrator
 * 
 * @param consulHost
 * @param consulPort
 * @param consulServiceName
 * @param consulTags
 * @param consulAclToken
 * @param consulSslEnabled
 * @param consulSslServerCertFilePath
 * @param consulSslServerCertBase64
 * @param consulServerHostnameVerify
 * @param localDiscoveryNode
 * @param registratorConfig
 * @param logger
 * @throws Exception
 */
public void init(String consulHost, 
		         Integer consulPort,
		         String consulServiceName,
		         String[] consulTags,
		         String consulAclToken,
		         boolean consulSslEnabled,
				 String	consulSslServerCertFilePath,
				 String consulSslServerCertBase64,
				 boolean consulServerHostnameVerify,
		         DiscoveryNode localDiscoveryNode,
		         Map<String, Object> registratorConfig,
		         ILogger logger) throws Exception;
 

@Override 
public Address determineMyLocalAddress(DiscoveryNode localDiscoveryNode, Map<String, Object> registratorConfig) throws Exception {

	String registerWithIpAddress = (String)registratorConfig.get(CONFIG_PROP_REGISTER_WITH_IP_ADDRESS);
	Integer registerWithPort = (Integer)registratorConfig.get(CONFIG_PROP_REGISTER_WITH_PORT);
	
	logger.info("Registrator config properties: " + CONFIG_PROP_REGISTER_WITH_IP_ADDRESS +":"+registerWithIpAddress 
										    + " " +  CONFIG_PROP_REGISTER_WITH_PORT + ":" + registerWithPort +
										    ", will attempt to register with this IP/PORT...");

	
	
	return new Address(registerWithIpAddress, registerWithPort);
}
 

abstract List<DiscoveryNode> resolve();