org.springframework.cloud.client.discovery.ReactiveDiscoveryClient Java Examples

@Bean
public ReactiveDiscoveryClient reactiveDiscoveryClient() {
	return new ReactiveDiscoveryClient() {
		@Override
		public String description() {
			return SERVICE_ID;
		}

		@Override
		public Flux<ServiceInstance> getInstances(String serviceId) {
			return Flux.just(instance("1host", false),
					instance("2host-secure", true));
		}

		@Override
		public Flux<String> getServices() {
			return Flux.just(SERVICE_ID);
		}
	};
}
 

@Bean
public ReactiveDiscoveryClient customDiscoveryClient() {
	return new ReactiveDiscoveryClient() {
		@Override
		public String description() {
			return "Custom Reactive Discovery Client";
		}

		@Override
		public Flux<ServiceInstance> getInstances(String serviceId) {
			return Flux.empty();
		}

		@Override
		public Flux<String> getServices() {
			return Flux.empty();
		}
	};
}
 

@Test
public void shouldReturnEmptyFluxWhenServiceHasNoSubsets(
		@Client KubernetesClient kubernetesClient,
		@Server KubernetesServer kubernetesServer) {
	kubernetesServer.expect().get().withPath("/api/v1/namespaces/test/services")
			.andReturn(200,
					new ServiceListBuilder().addNewItem().withNewMetadata()
							.withName("existing-service")
							.withLabels(new HashMap<String, String>() {
								{
									put("label", "value");
								}
							}).endMetadata().endItem().build())
			.once();

	KubernetesDiscoveryProperties properties = new KubernetesDiscoveryProperties();
	ReactiveDiscoveryClient client = new KubernetesReactiveDiscoveryClient(
			kubernetesClient, properties, KubernetesClient::services);
	Flux<ServiceInstance> instances = client.getInstances("existing-service");
	StepVerifier.create(instances).expectNextCount(0).expectComplete().verify();
}
 

@Bean
ReactiveDiscoveryClient discoveryClient() {
	return new ReactiveDiscoveryClient() {
		@Override
		public String description() {
			return "Reactive Test Discovery Client";
		}

		@Override
		public Flux<ServiceInstance> getInstances(String serviceId) {
			return Flux.empty();
		}

		@Override
		public Flux<String> getServices() {
			return Flux.empty();
		}
	};
}
 

@Test
public void shouldUseCustomServiceDiscovery() {
	contextRunner
			.withConfiguration(AutoConfigurations
					.of(ReactiveCommonsClientAutoConfiguration.class))
			.withUserConfiguration(
					CustomCloudFoundryReactiveDiscoveryClientConfiguration.class)
			.run(context -> {
				assertThat(context)
						.hasSingleBean(CloudFoundryReactiveHeartbeatSender.class);
				assertThat(context).getBeans(ReactiveDiscoveryClient.class)
						.hasSize(2);
				assertThat(context).hasBean("nativeCloudFoundryDiscoveryClient");
				assertThat(context)
						.hasSingleBean(ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldUseAppServiceDiscovery() {
	contextRunner
			.withConfiguration(AutoConfigurations
					.of(ReactiveCommonsClientAutoConfiguration.class))
			.withPropertyValues("spring.cloud.cloudfoundry.discovery.use-dns=true",
					"spring.cloud.cloudfoundry.discovery.use-container-ip=false")
			.run(context -> {
				assertThat(context)
						.hasSingleBean(CloudFoundryReactiveHeartbeatSender.class);
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).hasBean("appServiceReactiveDiscoveryClient");
				assertThat(context)
						.hasSingleBean(ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldUseDnsDiscovery() {
	contextRunner
			.withConfiguration(AutoConfigurations
					.of(ReactiveCommonsClientAutoConfiguration.class))
			.withPropertyValues("spring.cloud.cloudfoundry.discovery.use-dns=true",
					"spring.cloud.cloudfoundry.discovery.use-container-ip=true")
			.run(context -> {
				assertThat(context)
						.hasSingleBean(CloudFoundryReactiveHeartbeatSender.class);
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).hasBean("dnsBasedReactiveDiscoveryClient");
				assertThat(context)
						.hasSingleBean(ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldUseCustomConfiguration() {
	this.contextRunner.withUserConfiguration(Configuration.class)
			.withPropertyValues("spring.application.name=my-service",
					"spring.cloud.discovery.client.simple.order=1",
					"server.port=8443")
			.run((context) -> {
				ReactiveDiscoveryClient client = context
						.getBean(ReactiveDiscoveryClient.class);
				assertThat(client).isNotNull();
				assertThat(client.getOrder()).isEqualTo(1);
				InetUtils inet = context.getBean(InetUtils.class);
				assertThat(inet).isNotNull();
				SimpleReactiveDiscoveryProperties properties = context
						.getBean(SimpleReactiveDiscoveryProperties.class);
				assertThat(properties).isNotNull();
				assertThat(properties.getLocal().getServiceId())
						.isEqualTo("my-service");
				assertThat(properties.getLocal().getHost())
						.isEqualTo(inet.findFirstNonLoopbackHostInfo().getHostname());
				assertThat(properties.getLocal().getPort()).isEqualTo(8443);
			});
}
 

@Test
public void shouldUseDefaults() {
	this.contextRunner.run((context) -> {
		ReactiveDiscoveryClient client = context
				.getBean(ReactiveDiscoveryClient.class);
		assertThat(client).isNotNull();
		assertThat(client.getOrder())
				.isEqualTo(ReactiveDiscoveryClient.DEFAULT_ORDER);
		InetUtils inet = context.getBean(InetUtils.class);
		assertThat(inet).isNotNull();
		SimpleReactiveDiscoveryProperties properties = context
				.getBean(SimpleReactiveDiscoveryProperties.class);
		assertThat(properties).isNotNull();
		assertThat(properties.getLocal().getServiceId()).isEqualTo("application");
		assertThat(properties.getLocal().getHost())
				.isEqualTo(inet.findFirstNonLoopbackHostInfo().getHostname());
		assertThat(properties.getLocal().getPort()).isEqualTo(8080);
	});
}
 

private Mono<Health> doHealthCheck() {
	// @formatter:off
	return Mono.justOrEmpty(this.discoveryClient)
			.flatMapMany(ReactiveDiscoveryClient::getServices)
			.collectList()
			.defaultIfEmpty(emptyList())
			.map(services -> {
				ReactiveDiscoveryClient client = this.discoveryClient;
				String description = (this.properties.isIncludeDescription())
						? client.description() : "";
				return Health.status(new Status("UP", description))
						.withDetail("services", services).build();
			})
			.onErrorResume(exception -> {
				this.log.error("Error", exception);
				return Mono.just(Health.down().withException(exception).build());
			});
	// @formatter:on
}
 

@Bean
ServiceInstanceListSupplier supplier(ConfigurableApplicationContext context,
		ReactiveDiscoveryClient discoveryClient,
		LoadBalancerProperties loadBalancerProperties,
		WebClient.Builder webClientBuilder) {
	DiscoveryClientServiceInstanceListSupplier firstDelegate = new DiscoveryClientServiceInstanceListSupplier(
			discoveryClient, context.getEnvironment());
	HealthCheckServiceInstanceListSupplier delegate = new TestHealthCheckServiceInstanceListSupplier(
			firstDelegate, loadBalancerProperties.getHealthCheck(),
			webClientBuilder.build());
	delegate.afterPropertiesSet();
	ObjectProvider<LoadBalancerCacheManager> cacheManagerProvider = context
			.getBeanProvider(LoadBalancerCacheManager.class);
	return new CachingServiceInstanceListSupplier(delegate,
			cacheManagerProvider.getIfAvailable());
}
 

@Test
public void shouldNotHaveDiscoveryClientWhenConsulDisabled() {
	contextRunner.withPropertyValues("spring.cloud.consul.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean("consulReactiveDiscoveryClient");
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldNotHaveDiscoveryClientWhenEurekaClientDisabled() {
	contextRunner.withPropertyValues("eureka.client.enabled=false").run(context -> {
		assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
		assertThat(context)
				.doesNotHaveBean(ReactiveDiscoveryClientHealthIndicator.class);
	});
}
 

@Test
public void worksWithoutWebflux() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.web.reactive"))
			.run(context -> {
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldNotHaveDiscoveryClientWhenConsulDiscoveryDisabled() {
	contextRunner.withPropertyValues("spring.cloud.consul.discovery.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean("consulReactiveDiscoveryClient");
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldNotHaveDiscoveryClientWhenDiscoveryDisabled() {
	contextRunner.withPropertyValues("spring.cloud.discovery.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldWorkWithDefaults() {
	contextRunner.run(context -> {
		assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
		assertThat(context)
				.hasSingleBean(ReactiveDiscoveryClientHealthIndicator.class);
	});
}
 

@Test
public void shouldCreateCompositeReactiveDiscoveryClientWithDelegate() {
	this.contextRunner.withUserConfiguration(Configuration.class).run((context) -> {
		ReactiveDiscoveryClient client = context
				.getBean(ReactiveDiscoveryClient.class);
		assertThat(client).isNotNull();
		assertThat(client).isInstanceOf(ReactiveCompositeDiscoveryClient.class);
		assertThat(((ReactiveCompositeDiscoveryClient) client).getDiscoveryClients())
				.hasSize(1);
	});
}
 

@Test
public void shouldNotHaveDiscoveryClientWhenReactiveDiscoveryDisabled() {
	contextRunner.withPropertyValues("spring.cloud.discovery.reactive.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean("consulReactiveDiscoveryClient");
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldCreateCompositeReactiveDiscoveryClientWithoutDelegates() {
	this.contextRunner.run((context) -> {
		ReactiveDiscoveryClient client = context
				.getBean(ReactiveDiscoveryClient.class);
		assertThat(client).isNotNull();
		assertThat(client).isInstanceOf(ReactiveCompositeDiscoveryClient.class);
		assertThat(((ReactiveCompositeDiscoveryClient) client).getDiscoveryClients())
				.isEmpty();
	});
}
 

@Test
public void worksWithoutActuator() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.boot.actuate"))
			.run(context -> {
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Override
public Flux<String> getServices() {
	if (discoveryClients == null || discoveryClients.isEmpty()) {
		return Flux.empty();
	}
	return Flux.fromIterable(discoveryClients)
			.flatMap(ReactiveDiscoveryClient::getServices);
}
 

@Override
public Flux<ServiceInstance> getInstances(String serviceId) {
	if (discoveryClients == null || discoveryClients.isEmpty()) {
		return Flux.empty();
	}
	List<Flux<ServiceInstance>> serviceInstances = new ArrayList<>();
	for (ReactiveDiscoveryClient discoveryClient : discoveryClients) {
		serviceInstances.add(discoveryClient.getInstances(serviceId));
	}
	return CloudFlux.firstNonEmpty(serviceInstances);
}
 

@Test
public void shouldNotHaveDiscoveryClientsWhenDiscoveryDisabled() {
	contextRunner.withPropertyValues("spring.cloud.discovery.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean("cloudFoundryHeartbeatSender");
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutActuator() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.boot.actuate"))
			.run(context -> {
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldNotHaveDiscoveryClientsWhenReactiveDiscoveryDisabled() {
	contextRunner.withPropertyValues("spring.cloud.discovery.reactive.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean("cloudFoundryHeartbeatSender");
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldWorkWithDefaults() {
	contextRunner.run(context -> {
		assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
		assertThat(context)
				.hasSingleBean(ReactiveDiscoveryClientHealthIndicator.class);
	});
}
 

@Test
public void shouldNotHaveDiscoveryClientWhenDiscoveryDisabled() {
	contextRunner.withPropertyValues("spring.cloud.discovery.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean("consulReactiveDiscoveryClient");
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void shouldNotHaveDiscoveryClientsWhenCloudFoundryDiscoveryDisabled() {
	contextRunner
			.withPropertyValues("spring.cloud.cloudfoundry.discovery.enabled=false")
			.run(context -> {
				assertThat(context).doesNotHaveBean("cloudFoundryHeartbeatSender");
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutWebflux() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.web.reactive"))
			.run(context -> {
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}