From 7191e820a2657dd16b57425639785f0e7cc38dc7 Mon Sep 17 00:00:00 2001 From: Ryan Baxter Date: Fri, 23 Sep 2016 15:01:09 -0400 Subject: [PATCH 1/4] Implementing retry policy --- .../ribbon/RibbonLoadBalancerClient.java | 59 ++++++++++++++++--- .../ribbon/RibbonInterceptorTests.java | 16 +++-- 2 files changed, 61 insertions(+), 14 deletions(-) diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java index 4d00a9fb..811a48bb 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java @@ -16,22 +16,24 @@ package org.springframework.cloud.netflix.ribbon; -import java.io.IOException; -import java.net.URI; -import java.util.Collections; -import java.util.Map; - +import com.netflix.client.config.IClientConfig; +import com.netflix.loadbalancer.ILoadBalancer; +import com.netflix.loadbalancer.Server; import org.springframework.cloud.client.DefaultServiceInstance; import org.springframework.cloud.client.ServiceInstance; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; +import org.springframework.http.HttpMethod; import org.springframework.util.Assert; import org.springframework.util.ReflectionUtils; import org.springframework.web.util.UriComponentsBuilder; -import com.netflix.client.config.IClientConfig; -import com.netflix.loadbalancer.ILoadBalancer; -import com.netflix.loadbalancer.Server; +import java.io.IOException; +import java.net.URI; +import java.util.Collections; +import java.util.Map; /** * @author Spencer Gibb @@ -60,6 +62,33 @@ public class RibbonLoadBalancerClient implements LoadBalancerClient { return context.reconstructURIWithServer(server, uri); } + @Override + public LoadBalancedRetryPolicy getRetryPolicy(String serviceId) { + final RibbonLoadBalancerContext lbContext = this.clientFactory + .getLoadBalancerContext(serviceId); + return new LoadBalancedRetryPolicy() { + @Override + public boolean canRetry(LoadBalancedRetryContext context) { + HttpMethod method = context.getRequest().getMethod(); + if(HttpMethod.GET == method || lbContext.isOkToRetryOnAllOperations()) { + return true; + } else { + return false; + } + } + + @Override + public void close(LoadBalancedRetryContext context) { + + } + + @Override + public void registerThrowable(LoadBalancedRetryContext context, Throwable throwable) { + + } + }; + } + @Override public ServiceInstance choose(String serviceId) { Server server = getServer(serviceId); @@ -80,12 +109,24 @@ public class RibbonLoadBalancerClient implements LoadBalancerClient { RibbonServer ribbonServer = new RibbonServer(serviceId, server, isSecure(server, serviceId), serverIntrospector(serviceId).getMetadata(server)); + return execute(serviceId, ribbonServer, request); + } + + public T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest request) throws IOException { + Server server = null; + if(serviceInstance instanceof RibbonServer) { + server = ((RibbonServer)serviceInstance).getServer(); + } + if (server == null) { + throw new IllegalStateException("No instances available for " + serviceId); + } + RibbonLoadBalancerContext context = this.clientFactory .getLoadBalancerContext(serviceId); RibbonStatsRecorder statsRecorder = new RibbonStatsRecorder(context, server); try { - T returnVal = request.apply(ribbonServer); + T returnVal = request.apply(serviceInstance); statsRecorder.recordStats(returnVal); return returnVal; } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java index 41c3ebd9..dbdf52d7 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java @@ -16,15 +16,14 @@ package org.springframework.cloud.netflix.ribbon; -import java.net.URI; -import java.net.URL; - +import com.netflix.loadbalancer.Server; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.springframework.cloud.client.ServiceInstance; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor; import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; @@ -33,10 +32,12 @@ import org.springframework.http.HttpRequest; import org.springframework.http.client.ClientHttpRequestExecution; import org.springframework.http.client.ClientHttpResponse; import org.springframework.http.client.support.HttpRequestWrapper; +import org.springframework.retry.support.RetryTemplate; import org.springframework.util.ReflectionUtils; import org.springframework.web.util.UriComponentsBuilder; -import com.netflix.loadbalancer.Server; +import java.net.URI; +import java.net.URL; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -66,7 +67,7 @@ public class RibbonInterceptorTests { @Test public void testIntercept() throws Exception { RibbonServer server = new RibbonServer("myservice", new Server("myhost", 8080)); - LoadBalancerInterceptor interceptor = new LoadBalancerInterceptor(new MyClient(server)); + LoadBalancerInterceptor interceptor = new LoadBalancerInterceptor(new MyClient(server), new RetryTemplate()); given(this.request.getURI()).willReturn(new URL("http://myservice").toURI()); given(this.execution.execute(isA(HttpRequest.class), isA(byte[].class))) .willReturn(this.response); @@ -111,6 +112,11 @@ public class RibbonInterceptorTests { .port(instance.getPort()).build().toUri(); } + @Override + public LoadBalancedRetryPolicy getRetryPolicy(String serviceId) { + return null; + } + } } From 4c90ce437e5e2f29d77406907a3a96d6a6f02fee Mon Sep 17 00:00:00 2001 From: Ryan Baxter Date: Tue, 4 Oct 2016 10:48:40 -0400 Subject: [PATCH 2/4] Implementation of factory pattern for creating retry policies --- .../ribbon/RibbonAutoConfiguration.java | 6 + .../RibbonLoadBalancedRetryPolicyFactory.java | 92 ++++++++ .../ribbon/RibbonLoadBalancerClient.java | 34 +-- .../ribbon/RibbonInterceptorTests.java | 23 +- ...bonLoadBalancedRetryPolicyFactoryTest.java | 214 ++++++++++++++++++ 5 files changed, 331 insertions(+), 38 deletions(-) create mode 100644 spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java create mode 100644 spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTest.java diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java index a9729321..cc12ecd8 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java @@ -32,6 +32,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.cloud.client.actuator.HasFeatures; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.RestTemplateCustomizer; @@ -78,6 +79,11 @@ public class RibbonAutoConfiguration { return new RibbonLoadBalancerClient(springClientFactory()); } + @Bean + public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) { + return new RibbonLoadBalancedRetryPolicyFactory(clientFactory); + } + @Bean @ConditionalOnMissingBean public PropertiesFactory propertiesFactory() { diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java new file mode 100644 index 00000000..35facbe2 --- /dev/null +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java @@ -0,0 +1,92 @@ +/* + * Copyright 2013-2016 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.cloud.netflix.ribbon; + +import org.springframework.cloud.client.ServiceInstance; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; +import org.springframework.http.HttpMethod; + +/** + * @author Ryan Baxter + */ +public class RibbonLoadBalancedRetryPolicyFactory implements LoadBalancedRetryPolicyFactory { + + private SpringClientFactory clientFactory; + + public RibbonLoadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) { + this.clientFactory = clientFactory; + } + @Override + public LoadBalancedRetryPolicy create(final String serviceId, final LoadBalancerClient loadBalancerClient) { + final RibbonLoadBalancerContext lbContext = this.clientFactory + .getLoadBalancerContext(serviceId); + return new LoadBalancedRetryPolicy() { + private int sameServerCount = 0; + private int nextServerCount = 0; + private ServiceInstance lastServiceInstance = null; + public boolean canRetry(LoadBalancedRetryContext context) { + HttpMethod method = context.getRequest().getMethod(); + return HttpMethod.GET == method || lbContext.isOkToRetryOnAllOperations(); + } + + @Override + public boolean canRetrySameServer(LoadBalancedRetryContext context) { + return sameServerCount < lbContext.getRetryHandler().getMaxRetriesOnSameServer() && canRetry(context); + } + + @Override + public boolean canRetryNextServer(LoadBalancedRetryContext context) { + //this will be called after a failure occurs and we increment the counter + //so we check that the count is less than or equals to too make sure + //we try the next server the right number of times + return nextServerCount <= lbContext.getRetryHandler().getMaxRetriesOnNextServer() && canRetry(context); + } + + @Override + public void close(LoadBalancedRetryContext context) { + + } + + @Override + public void registerThrowable(LoadBalancedRetryContext context, Throwable throwable) { + //Check if we need to ask the load balancer for a new server. + //Do this before we increment the counters because the first call to this method + //is not a retry it is just an initial failure. + if(!canRetrySameServer(context) && canRetryNextServer(context)) { + context.setServiceInstance(loadBalancerClient.choose(serviceId)); + } + //This method is called regardless of whether we are retrying or making the first request. + //Since we do not count the initial request in the retry count we don't reset the counter + //until we actually equal the same server count limit. This will allow us to make the initial + //request plus the right number of retries. + if(sameServerCount >= lbContext.getRetryHandler().getMaxRetriesOnSameServer() && canRetry(context)) { + //reset same server since we are moving to a new server + sameServerCount = 0; + nextServerCount++; + if(!canRetryNextServer(context)) { + context.setExhaustedOnly(); + } + } else { + sameServerCount++; + } + + } + }; + } +} diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java index 811a48bb..96ef9ae2 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java @@ -21,11 +21,8 @@ import com.netflix.loadbalancer.ILoadBalancer; import com.netflix.loadbalancer.Server; import org.springframework.cloud.client.DefaultServiceInstance; import org.springframework.cloud.client.ServiceInstance; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; -import org.springframework.http.HttpMethod; import org.springframework.util.Assert; import org.springframework.util.ReflectionUtils; import org.springframework.web.util.UriComponentsBuilder; @@ -38,8 +35,9 @@ import java.util.Map; /** * @author Spencer Gibb * @author Dave Syer + * @author Ryan Baxter */ -public class RibbonLoadBalancerClient implements LoadBalancerClient { +public class RibbonLoadBalancerClient implements LoadBalancerClient{ private SpringClientFactory clientFactory; @@ -62,33 +60,6 @@ public class RibbonLoadBalancerClient implements LoadBalancerClient { return context.reconstructURIWithServer(server, uri); } - @Override - public LoadBalancedRetryPolicy getRetryPolicy(String serviceId) { - final RibbonLoadBalancerContext lbContext = this.clientFactory - .getLoadBalancerContext(serviceId); - return new LoadBalancedRetryPolicy() { - @Override - public boolean canRetry(LoadBalancedRetryContext context) { - HttpMethod method = context.getRequest().getMethod(); - if(HttpMethod.GET == method || lbContext.isOkToRetryOnAllOperations()) { - return true; - } else { - return false; - } - } - - @Override - public void close(LoadBalancedRetryContext context) { - - } - - @Override - public void registerThrowable(LoadBalancedRetryContext context, Throwable throwable) { - - } - }; - } - @Override public ServiceInstance choose(String serviceId) { Server server = getServer(serviceId); @@ -112,6 +83,7 @@ public class RibbonLoadBalancerClient implements LoadBalancerClient { return execute(serviceId, ribbonServer, request); } + @Override public T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest request) throws IOException { Server server = null; if(serviceInstance instanceof RibbonServer) { diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java index dbdf52d7..644a7c37 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java @@ -23,10 +23,11 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.springframework.cloud.client.ServiceInstance; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor; import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; +import org.springframework.cloud.client.loadbalancer.LoadBalancerRetryProperties; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient.RibbonServer; import org.springframework.http.HttpRequest; import org.springframework.http.client.ClientHttpRequestExecution; @@ -36,6 +37,7 @@ import org.springframework.retry.support.RetryTemplate; import org.springframework.util.ReflectionUtils; import org.springframework.web.util.UriComponentsBuilder; +import java.io.IOException; import java.net.URI; import java.net.URL; @@ -67,7 +69,8 @@ public class RibbonInterceptorTests { @Test public void testIntercept() throws Exception { RibbonServer server = new RibbonServer("myservice", new Server("myhost", 8080)); - LoadBalancerInterceptor interceptor = new LoadBalancerInterceptor(new MyClient(server), new RetryTemplate()); + LoadBalancerInterceptor interceptor = new LoadBalancerInterceptor(new MyClient(server), new RetryTemplate(), + new LoadBalancerRetryProperties(), new LoadBalancedRetryPolicyFactory.NeverRetryFactory()); given(this.request.getURI()).willReturn(new URL("http://myservice").toURI()); given(this.execution.execute(isA(HttpRequest.class), isA(byte[].class))) .willReturn(this.response); @@ -106,17 +109,23 @@ public class RibbonInterceptorTests { return null; } + @Override + public T execute(String s, ServiceInstance serviceInstance, LoadBalancerRequest request) throws IOException { + try { + return request.apply(this.instance); + } + catch (Exception ex) { + ReflectionUtils.rethrowRuntimeException(ex); + } + return null; + } + @Override public URI reconstructURI(ServiceInstance instance, URI original) { return UriComponentsBuilder.fromUri(original).host(instance.getHost()) .port(instance.getPort()).build().toUri(); } - @Override - public LoadBalancedRetryPolicy getRetryPolicy(String serviceId) { - return null; - } - } } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTest.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTest.java new file mode 100644 index 00000000..aecf19bc --- /dev/null +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTest.java @@ -0,0 +1,214 @@ +package org.springframework.cloud.netflix.ribbon; + +import com.netflix.client.DefaultLoadBalancerRetryHandler; +import com.netflix.client.config.CommonClientConfigKey; +import com.netflix.client.config.IClientConfig; +import com.netflix.loadbalancer.BaseLoadBalancer; +import com.netflix.loadbalancer.LoadBalancerStats; +import com.netflix.loadbalancer.Server; +import com.netflix.loadbalancer.ServerStats; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.cloud.client.ServiceInstance; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpRequest; +import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient.RibbonServer; + +import java.io.IOException; +import java.util.Collections; +import java.util.Map; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.mockito.BDDMockito.given; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyBoolean; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +/** + * @author Ryan Baxter + */ +public class RibbonLoadBalancedRetryPolicyFactoryTest { + + @Mock + private SpringClientFactory clientFactory; + + @Mock + private BaseLoadBalancer loadBalancer; + + @Mock + private LoadBalancerStats loadBalancerStats; + + @Mock + private ServerStats serverStats; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + given(this.clientFactory.getLoadBalancerContext(anyString())).willReturn( + new RibbonLoadBalancerContext(this.loadBalancer)); + given(this.clientFactory.getInstance(anyString(), eq(ServerIntrospector.class))) + .willReturn(new DefaultServerIntrospector() { + @Override + public Map getMetadata(Server server) { + return Collections.singletonMap("mykey", "myvalue"); + } + }); + + } + + @After + public void tearDown() throws Exception {} + + @Test + public void testGetRetryPolicyNoRetry() throws Exception { + int sameServer = 0; + int nextServer = 0; + boolean retryOnAllOps = false; + RibbonServer server = getRibbonServer(); + IClientConfig config = mock(IClientConfig.class); + doReturn(sameServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetries), anyInt()); + doReturn(sameServer).when(config).getPropertyAsInteger(eq(CommonClientConfigKey.MaxAutoRetries), anyInt()); + doReturn(nextServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt()); + doReturn(nextServer).when(config).getPropertyAsInteger(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt()); + doReturn(retryOnAllOps).when(config).get(eq(CommonClientConfigKey.OkToRetryOnAllOperations), anyBoolean()); + doReturn(retryOnAllOps).when(config).getPropertyAsBoolean(eq(CommonClientConfigKey.OkToRetryOnAllOperations), anyBoolean()); + doReturn(server.getServiceId()).when(config).getClientName(); + doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId())); + clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config)); + RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server); + RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client); + HttpRequest request = mock(HttpRequest.class); + doReturn(HttpMethod.GET).when(request).getMethod(); + LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request); + assertThat(policy.canRetryNextServer(context), is(true)); + assertThat(policy.canRetrySameServer(context), is(false)); + } + + @Test + public void testGetRetryPolicyNotGet() throws Exception { + int sameServer = 3; + int nextServer = 3; + boolean retryOnAllOps = false; + RibbonServer server = getRibbonServer(); + IClientConfig config = mock(IClientConfig.class); + doReturn(sameServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetries), anyInt()); + doReturn(sameServer).when(config).getPropertyAsInteger(eq(CommonClientConfigKey.MaxAutoRetries), anyInt()); + doReturn(nextServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt()); + doReturn(nextServer).when(config).getPropertyAsInteger(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt()); + doReturn(retryOnAllOps).when(config).get(eq(CommonClientConfigKey.OkToRetryOnAllOperations), anyBoolean()); + doReturn(retryOnAllOps).when(config).getPropertyAsBoolean(eq(CommonClientConfigKey.OkToRetryOnAllOperations), anyBoolean()); + doReturn(server.getServiceId()).when(config).getClientName(); + doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId())); + clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config)); + RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server); + RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client); + HttpRequest request = mock(HttpRequest.class); + doReturn(HttpMethod.POST).when(request).getMethod(); + LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request); + assertThat(policy.canRetryNextServer(context), is(false)); + assertThat(policy.canRetrySameServer(context), is(false)); + } + + @Test + public void testGetRetryPolicyRetryOnNonGet() throws Exception { + int sameServer = 3; + int nextServer = 3; + boolean retryOnAllOps = true; + RibbonServer server = getRibbonServer(); + IClientConfig config = mock(IClientConfig.class); + doReturn(sameServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetries), anyInt()); + doReturn(sameServer).when(config).getPropertyAsInteger(eq(CommonClientConfigKey.MaxAutoRetries), anyInt()); + doReturn(nextServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt()); + doReturn(nextServer).when(config).getPropertyAsInteger(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt()); + doReturn(retryOnAllOps).when(config).get(eq(CommonClientConfigKey.OkToRetryOnAllOperations), anyBoolean()); + doReturn(retryOnAllOps).when(config).getPropertyAsBoolean(eq(CommonClientConfigKey.OkToRetryOnAllOperations), anyBoolean()); + doReturn(server.getServiceId()).when(config).getClientName(); + doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId())); + clientFactory.getLoadBalancerContext(server.getServiceId()).initWithNiwsConfig(config); + RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server); + RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client); + HttpRequest request = mock(HttpRequest.class); + doReturn(HttpMethod.POST).when(request).getMethod(); + LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request); + assertThat(policy.canRetryNextServer(context), is(true)); + assertThat(policy.canRetrySameServer(context), is(true)); + } + + @Test + public void testGetRetryPolicyRetryCount() throws Exception { + int sameServer = 3; + int nextServer = 3; + RibbonServer server = getRibbonServer(); + IClientConfig config = mock(IClientConfig.class); + doReturn(sameServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetries), anyInt()); + doReturn(nextServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt()); + doReturn(false).when(config).get(eq(CommonClientConfigKey.OkToRetryOnAllOperations), eq(false)); + doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId())); + clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config)); + RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server); + RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client); + HttpRequest request = mock(HttpRequest.class); + doReturn(HttpMethod.GET).when(request).getMethod(); + LoadBalancedRetryContext context = spy(new LoadBalancedRetryContext(null, request)); + //Loop through as if we are retrying a request until we exhaust the number of retries + //outer loop is for next server retries + //inner loop is for same server retries + for(int i = 0; i < nextServer + 1; i++) { + //iterate once time beyond the same server retry limit to cause us to reset + //the same sever counter and increment the next server counter + for(int j = 0; j < sameServer + 1; j++) { + if(j < 3) { + assertThat(policy.canRetrySameServer(context), is(true)); + } else { + assertThat(policy.canRetrySameServer(context), is(false)); + } + policy.registerThrowable(context, new IOException()); + } + if(i < 3) { + assertThat(policy.canRetryNextServer(context), is(true)); + } else { + assertThat(policy.canRetryNextServer(context), is(false)); + } + } + assertThat(context.isExhaustedOnly(), is(true)); + verify(context, times(4)).setServiceInstance(any(ServiceInstance.class)); + } + + protected RibbonLoadBalancerClient getRibbonLoadBalancerClient( + RibbonServer ribbonServer) { + given(this.loadBalancer.getName()).willReturn(ribbonServer.getServiceId()); + given(this.loadBalancer.chooseServer(anyObject())).willReturn( + ribbonServer.getServer()); + given(this.loadBalancer.getLoadBalancerStats()) + .willReturn(this.loadBalancerStats); + given(this.loadBalancerStats.getSingleServerStat(ribbonServer.getServer())) + .willReturn(this.serverStats); + given(this.clientFactory.getLoadBalancer(this.loadBalancer.getName())) + .willReturn(this.loadBalancer); + return new RibbonLoadBalancerClient(this.clientFactory); + } + + protected RibbonServer getRibbonServer() { + return new RibbonServer("testService", new Server("myhost", 9080), false, + Collections.singletonMap("mykey", "myvalue")); + } + +} \ No newline at end of file From 5a42cb1b2b3ab26b2acf0f1f277d0f2b4ff63975 Mon Sep 17 00:00:00 2001 From: Ryan Baxter Date: Thu, 20 Oct 2016 15:09:52 -0400 Subject: [PATCH 3/4] Updates based on latest version from commons --- spring-cloud-netflix-core/pom.xml | 8 ++++++++ .../RibbonLoadBalancedRetryPolicyFactory.java | 7 ++++--- .../netflix/ribbon/RibbonInterceptorTests.java | 15 +++++---------- 3 files changed, 17 insertions(+), 13 deletions(-) diff --git a/spring-cloud-netflix-core/pom.xml b/spring-cloud-netflix-core/pom.xml index 3343772a..fcd3c659 100644 --- a/spring-cloud-netflix-core/pom.xml +++ b/spring-cloud-netflix-core/pom.xml @@ -44,6 +44,14 @@ spring-boot-starter-web true + + org.springframework.boot + spring-boot-starter-aop + + + org.springframework.retry + spring-retry + org.springframework.cloud spring-cloud-commons diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java index 35facbe2..65f84354 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java @@ -16,10 +16,10 @@ package org.springframework.cloud.netflix.ribbon; import org.springframework.cloud.client.ServiceInstance; +import org.springframework.cloud.client.loadbalancer.LoadBalanceChooser; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.http.HttpMethod; /** @@ -32,8 +32,9 @@ public class RibbonLoadBalancedRetryPolicyFactory implements LoadBalancedRetryPo public RibbonLoadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) { this.clientFactory = clientFactory; } + @Override - public LoadBalancedRetryPolicy create(final String serviceId, final LoadBalancerClient loadBalancerClient) { + public LoadBalancedRetryPolicy create(final String serviceId, final LoadBalanceChooser loadBalanceChooser) { final RibbonLoadBalancerContext lbContext = this.clientFactory .getLoadBalancerContext(serviceId); return new LoadBalancedRetryPolicy() { @@ -69,7 +70,7 @@ public class RibbonLoadBalancedRetryPolicyFactory implements LoadBalancedRetryPo //Do this before we increment the counters because the first call to this method //is not a retry it is just an initial failure. if(!canRetrySameServer(context) && canRetryNextServer(context)) { - context.setServiceInstance(loadBalancerClient.choose(serviceId)); + context.setServiceInstance(loadBalanceChooser.choose(serviceId)); } //This method is called regardless of whether we are retrying or making the first request. //Since we do not count the initial request in the retry count we don't reset the counter diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java index 644a7c37..aa9bb89e 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonInterceptorTests.java @@ -16,30 +16,26 @@ package org.springframework.cloud.netflix.ribbon; -import com.netflix.loadbalancer.Server; +import java.io.IOException; +import java.net.URI; +import java.net.URL; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.springframework.cloud.client.ServiceInstance; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor; import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; -import org.springframework.cloud.client.loadbalancer.LoadBalancerRetryProperties; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient.RibbonServer; import org.springframework.http.HttpRequest; import org.springframework.http.client.ClientHttpRequestExecution; import org.springframework.http.client.ClientHttpResponse; import org.springframework.http.client.support.HttpRequestWrapper; -import org.springframework.retry.support.RetryTemplate; import org.springframework.util.ReflectionUtils; import org.springframework.web.util.UriComponentsBuilder; - -import java.io.IOException; -import java.net.URI; -import java.net.URL; +import com.netflix.loadbalancer.Server; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -69,8 +65,7 @@ public class RibbonInterceptorTests { @Test public void testIntercept() throws Exception { RibbonServer server = new RibbonServer("myservice", new Server("myhost", 8080)); - LoadBalancerInterceptor interceptor = new LoadBalancerInterceptor(new MyClient(server), new RetryTemplate(), - new LoadBalancerRetryProperties(), new LoadBalancedRetryPolicyFactory.NeverRetryFactory()); + LoadBalancerInterceptor interceptor = new LoadBalancerInterceptor(new MyClient(server)); given(this.request.getURI()).willReturn(new URL("http://myservice").toURI()); given(this.execution.execute(isA(HttpRequest.class), isA(byte[].class))) .willReturn(this.response); From 5a5a1aaa7f71e6d8093d7bf5d19adaca152892a7 Mon Sep 17 00:00:00 2001 From: Ryan Baxter Date: Wed, 26 Oct 2016 15:04:51 -0400 Subject: [PATCH 4/4] -Made spring-retry optional -additional refactoring from changes in s-c-commons --- pom.xml | 7 +++ spring-cloud-netflix-core/pom.xml | 8 +++ .../ribbon/RibbonAutoConfiguration.java | 4 ++ .../RibbonLoadBalancedRetryPolicyFactory.java | 4 +- .../ribbon/RibbonLoadBalancerClient.java | 18 +++--- .../ribbon/SpringRetryDisabledTests.java | 63 +++++++++++++++++++ .../ribbon/SpringRetryEnabledTests.java | 56 +++++++++++++++++ spring-cloud-starter-ribbon/pom.xml | 8 +++ 8 files changed, 156 insertions(+), 12 deletions(-) create mode 100644 spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java create mode 100644 spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java diff --git a/pom.xml b/pom.xml index ef239e18..89ac5e98 100644 --- a/pom.xml +++ b/pom.xml @@ -79,6 +79,13 @@ pom import + + org.springframework.cloud + spring-cloud-commons + test-jar + test + ${spring-cloud-commons.version} + org.springframework.cloud spring-cloud-config-dependencies diff --git a/spring-cloud-netflix-core/pom.xml b/spring-cloud-netflix-core/pom.xml index fcd3c659..4260ddb0 100644 --- a/spring-cloud-netflix-core/pom.xml +++ b/spring-cloud-netflix-core/pom.xml @@ -47,10 +47,12 @@ org.springframework.boot spring-boot-starter-aop + true org.springframework.retry spring-retry + true org.springframework.cloud @@ -191,6 +193,12 @@ spring-boot-starter-test test + + org.springframework.cloud + spring-cloud-commons + test-jar + test + org.aspectj aspectjweaver diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java index cc12ecd8..55f48ecb 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java @@ -28,6 +28,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.AutoConfigureAfter; import org.springframework.boot.autoconfigure.AutoConfigureBefore; import org.springframework.boot.autoconfigure.condition.AnyNestedCondition; +import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; @@ -36,9 +37,11 @@ import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFact import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.RestTemplateCustomizer; +import org.springframework.cloud.client.loadbalancer.RetryLoadBalancerInterceptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; +import org.springframework.retry.support.RetryTemplate; import org.springframework.web.client.RestTemplate; import com.netflix.client.IClient; @@ -80,6 +83,7 @@ public class RibbonAutoConfiguration { } @Bean + @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) { return new RibbonLoadBalancedRetryPolicyFactory(clientFactory); } diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java index 65f84354..563071c3 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java @@ -16,10 +16,10 @@ package org.springframework.cloud.netflix.ribbon; import org.springframework.cloud.client.ServiceInstance; -import org.springframework.cloud.client.loadbalancer.LoadBalanceChooser; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser; import org.springframework.http.HttpMethod; /** @@ -34,7 +34,7 @@ public class RibbonLoadBalancedRetryPolicyFactory implements LoadBalancedRetryPo } @Override - public LoadBalancedRetryPolicy create(final String serviceId, final LoadBalanceChooser loadBalanceChooser) { + public LoadBalancedRetryPolicy create(final String serviceId, final ServiceInstanceChooser loadBalanceChooser) { final RibbonLoadBalancerContext lbContext = this.clientFactory .getLoadBalancerContext(serviceId); return new LoadBalancedRetryPolicy() { diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java index ca6ddfd8..414e8674 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancerClient.java @@ -16,28 +16,26 @@ package org.springframework.cloud.netflix.ribbon; -import com.netflix.client.config.IClientConfig; -import com.netflix.loadbalancer.ILoadBalancer; -import com.netflix.loadbalancer.Server; +import java.io.IOException; +import java.net.URI; +import java.util.Collections; +import java.util.Map; import org.springframework.cloud.client.DefaultServiceInstance; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; import org.springframework.util.Assert; import org.springframework.util.ReflectionUtils; -import org.springframework.web.util.UriComponentsBuilder; - -import java.io.IOException; -import java.net.URI; -import java.util.Collections; -import java.util.Map; +import com.netflix.client.config.IClientConfig; +import com.netflix.loadbalancer.ILoadBalancer; +import com.netflix.loadbalancer.Server; /** * @author Spencer Gibb * @author Dave Syer * @author Ryan Baxter */ -public class RibbonLoadBalancerClient implements LoadBalancerClient{ +public class RibbonLoadBalancerClient implements LoadBalancerClient { private SpringClientFactory clientFactory; diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java new file mode 100644 index 00000000..3317c567 --- /dev/null +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java @@ -0,0 +1,63 @@ +/* + * + * * Copyright 2013-2016 the original author or authors. + * * + * * Licensed under the Apache License, Version 2.0 (the "License"); + * * you may not use this file except in compliance with the License. + * * You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.springframework.cloud.netflix.ribbon; + +import java.util.Map; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.builder.SpringApplicationBuilder; +import org.springframework.cloud.ClassPathExclusions; +import org.springframework.cloud.FilteredClassPathRunner; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; +import org.springframework.context.ConfigurableApplicationContext; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; + +/** + * @author Ryan Baxter + */ +@RunWith(FilteredClassPathRunner.class) +@ClassPathExclusions({"spring-retry-*.jar", "spring-boot-starter-aop-*.jar"}) +public class SpringRetryDisabledTests { + + private ConfigurableApplicationContext context; + + @Before + public void setUp() { + context = new SpringApplicationBuilder().web(false) + .sources(RibbonAutoConfiguration.class,LoadBalancerAutoConfiguration.class).run(); + } + + @After + public void tearDown() { + if(context != null) { + context.close(); + } + } + + @Test + public void testLoadBalancedRetryFactoryBean() throws Exception { + Map factories = context.getBeansOfType(LoadBalancedRetryPolicyFactory.class); + assertThat(factories.values(), hasSize(0)); + } +} diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java new file mode 100644 index 00000000..539b94bc --- /dev/null +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java @@ -0,0 +1,56 @@ +/* + * + * * Copyright 2013-2016 the original author or authors. + * * + * * Licensed under the Apache License, Version 2.0 (the "License"); + * * you may not use this file except in compliance with the License. + * * You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package org.springframework.cloud.netflix.ribbon; + +import java.util.Map; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.BeansException; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.collection.IsCollectionWithSize.hasSize; + +/** + * @author Ryan Baxter + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {RibbonAutoConfiguration.class, LoadBalancerAutoConfiguration.class}) +public class SpringRetryEnabledTests implements ApplicationContextAware { + + private ApplicationContext context; + + @Test + public void testLoadBalancedRetryFactoryBean() throws Exception { + Map factories = context.getBeansOfType(LoadBalancedRetryPolicyFactory.class); + assertThat(factories.values(), hasSize(1)); + assertThat(factories.values().toArray()[0], instanceOf(RibbonLoadBalancedRetryPolicyFactory.class)); + } + + @Override + public void setApplicationContext(ApplicationContext context) throws BeansException { + this.context = context; + } +} diff --git a/spring-cloud-starter-ribbon/pom.xml b/spring-cloud-starter-ribbon/pom.xml index 4a31be7c..549ad625 100644 --- a/spring-cloud-starter-ribbon/pom.xml +++ b/spring-cloud-starter-ribbon/pom.xml @@ -20,6 +20,14 @@ ${basedir}/../.. + + org.springframework.boot + spring-boot-starter-aop + + + org.springframework.retry + spring-retry + org.springframework.cloud spring-cloud-starter