org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer Java Examples

@Test
public void shouldThrow4O4ExceptionWhenNoServiceInstanceIsFound() {
	URI uri = UriComponentsBuilder.fromUriString("lb://service1").build().toUri();
	exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, uri);
	RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(
			ServiceInstanceListSuppliers.toProvider("service1"), "service1", -1);
	when(clientFactory.getInstance("service1", ReactorLoadBalancer.class,
			ServiceInstance.class)).thenReturn(loadBalancer);
	properties.setUse404(true);
	ReactiveLoadBalancerClientFilter filter = new ReactiveLoadBalancerClientFilter(
			clientFactory, properties);
	when(chain.filter(exchange)).thenReturn(Mono.empty());
	try {
		filter.filter(exchange, chain).block();
	}
	catch (NotFoundException exception) {
		assertThat(exception.getStatus()).isEqualTo(HttpStatus.NOT_FOUND);
	}
}
 

@Bean
@ConditionalOnMissingBean
public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(
		Environment environment,
		LoadBalancerClientFactory loadBalancerClientFactory) {
	String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
	return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name,
			ServiceInstanceListSupplier.class), name);
}
 

private Mono<Response<ServiceInstance>> choose(ServerWebExchange exchange) {
	URI uri = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
	ReactorLoadBalancer<ServiceInstance> loadBalancer = this.clientFactory
			.getInstance(uri.getHost(), ReactorLoadBalancer.class,
					ServiceInstance.class);
	if (loadBalancer == null) {
		throw new NotFoundException("No loadbalancer available for " + uri.getHost());
	}
	return loadBalancer.choose(createRequest());
}
 

@SuppressWarnings("unchecked")
@Test
public void shouldFilter() {
	URI url = UriComponentsBuilder.fromUriString("lb://myservice").build().toUri();
	exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, url);

	ServiceInstance serviceInstance = new DefaultServiceInstance("myservice1",
			"myservice", "localhost", 8080, true);

	RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(
			ServiceInstanceListSuppliers.toProvider("myservice", serviceInstance),
			"myservice", -1);
	when(clientFactory.getInstance("myservice", ReactorLoadBalancer.class,
			ServiceInstance.class)).thenReturn(loadBalancer);

	when(chain.filter(exchange)).thenReturn(Mono.empty());

	filter.filter(exchange, chain).block();

	assertThat((LinkedHashSet<URI>) exchange
			.getAttribute(GATEWAY_ORIGINAL_REQUEST_URL_ATTR)).contains(url);

	verify(clientFactory).getInstance("myservice", ReactorLoadBalancer.class,
			ServiceInstance.class);

	verifyNoMoreInteractions(clientFactory);

	assertThat((URI) exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR))
			.isEqualTo(URI.create("https://localhost:8080/mypath"));

	verify(chain).filter(exchange);
	verifyNoMoreInteractions(chain);
}
 

@Bean
@ConditionalOnMissingBean
public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(
		Environment environment,
		LoadBalancerClientFactory loadBalancerClientFactory) {
	String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
	return new RoundRobinLoadBalancer(loadBalancerClientFactory.getLazyProvider(name,
			ServiceInstanceListSupplier.class), name);
}
 

@Bean
ReactorLoadBalancer<ServiceInstance> reactiveLoadBalancer(
		DiscoveryClient discoveryClient) {
	return new DiscoveryClientBasedReactiveLoadBalancer("myservice",
			discoveryClient);
}
 

@Bean
ReactorLoadBalancer<ServiceInstance> reactiveLoadBalancer(
		DiscoveryClient discoveryClient) {
	return new DiscoveryClientBasedReactiveLoadBalancer("unknownservice",
			discoveryClient);
}