From 6dec4afef823a4c31886cca00c2d1e6182c7954c Mon Sep 17 00:00:00 2001 From: Ryan Baxter Date: Mon, 12 Mar 2018 16:56:30 -0400 Subject: [PATCH] Refactor Spring Retry based on changes in commons (#2771) --- .../ribbon/RibbonAutoConfiguration.java | 29 +-- ...va => RibbonLoadBalancedRetryFactory.java} | 24 ++- .../apache/HttpClientRibbonConfiguration.java | 15 +- ...etryableRibbonLoadBalancingHttpClient.java | 57 +----- .../okhttp/OkHttpRibbonConfiguration.java | 12 +- .../RetryableOkHttpLoadBalancingClient.java | 46 +---- ... RibbonLoadBalancedRetryFactoryTests.java} | 26 +-- .../ribbon/SpringRetryDisabledTests.java | 7 +- .../ribbon/SpringRetryEnabledTests.java | 7 +- .../RibbonLoadBalancingHttpClientTests.java | 172 +++++++++--------- .../SpringRetryDisableOkHttpClientTests.java | 7 +- .../SpringRetryEnabledOkHttpClientTests.java | 10 +- .../RibbonRetryIntegrationTestBase.java | 16 +- 13 files changed, 168 insertions(+), 260 deletions(-) rename spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/{RibbonLoadBalancedRetryPolicyFactory.java => RibbonLoadBalancedRetryFactory.java} (58%) rename spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/{RibbonLoadBalancedRetryPolicyFactoryTests.java => RibbonLoadBalancedRetryFactoryTests.java} (92%) diff --git a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java index d6e5f2750..f23d6c290 100644 --- a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java +++ b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonAutoConfiguration.java @@ -34,9 +34,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.cloud.client.actuator.HasFeatures; import org.springframework.cloud.client.loadbalancer.AsyncLoadBalancerAutoConfiguration; -import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; import org.springframework.cloud.client.loadbalancer.RestTemplateCustomizer; @@ -91,29 +89,8 @@ public class RibbonAutoConfiguration { @Bean @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") @ConditionalOnMissingBean - public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) { - return new RibbonLoadBalancedRetryPolicyFactory(clientFactory); - } - - @Bean - @ConditionalOnMissingClass(value = "org.springframework.retry.support.RetryTemplate") - @ConditionalOnMissingBean - public LoadBalancedRetryPolicyFactory neverRetryPolicyFactory() { - return new LoadBalancedRetryPolicyFactory.NeverRetryFactory(); - } - - @Bean - @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") - @ConditionalOnMissingBean - public LoadBalancedBackOffPolicyFactory loadBalancedBackoffPolicyFactory() { - return new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - } - - @Bean - @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") - @ConditionalOnMissingBean - public LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory() { - return new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); + public LoadBalancedRetryFactory loadBalancedRetryPolicyFactory(final SpringClientFactory clientFactory) { + return new RibbonLoadBalancedRetryFactory(clientFactory); } @Bean diff --git a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryFactory.java similarity index 58% rename from spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java rename to spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryFactory.java index f1ee00018..de307a9d1 100644 --- a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactory.java +++ b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryFactory.java @@ -15,26 +15,38 @@ */ package org.springframework.cloud.netflix.ribbon; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser; +import org.springframework.retry.RetryListener; +import org.springframework.retry.backoff.BackOffPolicy; /** * @author Ryan Baxter */ -public class RibbonLoadBalancedRetryPolicyFactory implements LoadBalancedRetryPolicyFactory { +public class RibbonLoadBalancedRetryFactory implements LoadBalancedRetryFactory { private SpringClientFactory clientFactory; - public RibbonLoadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) { + public RibbonLoadBalancedRetryFactory(SpringClientFactory clientFactory) { this.clientFactory = clientFactory; } @Override - public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser loadBalanceChooser) { + public LoadBalancedRetryPolicy createRetryPolicy(String service, ServiceInstanceChooser serviceInstanceChooser) { RibbonLoadBalancerContext lbContext = this.clientFactory - .getLoadBalancerContext(serviceId); - return new RibbonLoadBalancedRetryPolicy(serviceId, lbContext, loadBalanceChooser, clientFactory.getClientConfig(serviceId)); + .getLoadBalancerContext(service); + return new RibbonLoadBalancedRetryPolicy(service, lbContext, serviceInstanceChooser, clientFactory.getClientConfig(service)); + } + + @Override + public RetryListener[] createRetryListeners(String service) { + return new RetryListener[0]; + } + + @Override + public BackOffPolicy createBackOffPolicy(String service) { + return null; } } diff --git a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/HttpClientRibbonConfiguration.java b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/HttpClientRibbonConfiguration.java index f05ac558b..afad077f0 100644 --- a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/HttpClientRibbonConfiguration.java +++ b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/HttpClientRibbonConfiguration.java @@ -32,9 +32,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; -import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.commons.httpclient.ApacheHttpClientConnectionManagerFactory; import org.springframework.cloud.commons.httpclient.ApacheHttpClientFactory; import org.springframework.cloud.netflix.ribbon.RibbonClientName; @@ -133,14 +131,11 @@ public class HttpClientRibbonConfiguration { @ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class) @ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate") public RetryableRibbonLoadBalancingHttpClient retryableRibbonLoadBalancingHttpClient( - IClientConfig config, ServerIntrospector serverIntrospector, - ILoadBalancer loadBalancer, RetryHandler retryHandler, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, CloseableHttpClient httpClient, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory, - LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) { + IClientConfig config, ServerIntrospector serverIntrospector, + ILoadBalancer loadBalancer, RetryHandler retryHandler, + LoadBalancedRetryFactory loadBalancedRetryFactory, CloseableHttpClient httpClient) { RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient( - httpClient, config, serverIntrospector, loadBalancedRetryPolicyFactory, - loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory); + httpClient, config, serverIntrospector, loadBalancedRetryFactory); client.setLoadBalancer(loadBalancer); client.setRetryHandler(retryHandler); Monitors.registerObject("Client_" + this.name, client); diff --git a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/RetryableRibbonLoadBalancingHttpClient.java b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/RetryableRibbonLoadBalancingHttpClient.java index 602768d99..6e922953d 100644 --- a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/RetryableRibbonLoadBalancingHttpClient.java +++ b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/RetryableRibbonLoadBalancingHttpClient.java @@ -23,12 +23,10 @@ import org.apache.http.client.config.RequestConfig; import org.apache.http.client.methods.HttpUriRequest; import org.apache.http.impl.client.CloseableHttpClient; import org.springframework.cloud.client.ServiceInstance; -import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRecoveryCallback; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; -import org.springframework.cloud.client.loadbalancer.RibbonRecoveryCallback; import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser; import org.springframework.cloud.client.loadbalancer.InterceptorRetryPolicy; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient; @@ -56,50 +54,13 @@ import com.netflix.loadbalancer.Server; */ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingHttpClient implements ServiceInstanceChooser { - private LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory = new LoadBalancedRetryPolicyFactory.NeverRetryFactory(); - private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory = - new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory = - new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); - - @Deprecated - //TODO remove in 2.0.x - public RetryableRibbonLoadBalancingHttpClient(IClientConfig config, - ServerIntrospector serverIntrospector, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) { - super(config, serverIntrospector); - this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory; - } - - @Deprecated - //TODO remove in 2.0.x - public RetryableRibbonLoadBalancingHttpClient(CloseableHttpClient delegate, - IClientConfig config, ServerIntrospector serverIntrospector, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) { - super(delegate, config, serverIntrospector); - this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory; - } - - @Deprecated - //TODO remove in 2.0.x - public RetryableRibbonLoadBalancingHttpClient(CloseableHttpClient delegate, - IClientConfig config, ServerIntrospector serverIntrospector, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) { - super(delegate, config, serverIntrospector); - this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory; - this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory; - } + private LoadBalancedRetryFactory loadBalancedRetryFactory; public RetryableRibbonLoadBalancingHttpClient(CloseableHttpClient delegate, IClientConfig config, ServerIntrospector serverIntrospector, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory, - LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) { + LoadBalancedRetryFactory loadBalancedRetryFactory) { super(delegate, config, serverIntrospector); - this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory; - this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory; - this.loadBalancedRetryListenerFactory = loadBalancedRetryListenerFactory; + this.loadBalancedRetryFactory = loadBalancedRetryFactory; } @Override @@ -112,7 +73,7 @@ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingH builder.setRedirectsEnabled(ribbon.isFollowRedirects(this.followRedirects)); final RequestConfig requestConfig = builder.build(); - final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryPolicyFactory.create(this.getClientName(), this); + final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory.createRetryPolicy(this.getClientName(), this); RetryCallback retryCallback = context -> { //on retries the policy will choose the server and set it in the context @@ -138,7 +99,7 @@ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingH } return new RibbonApacheHttpResponse(httpResponse, httpUriRequest.getURI()); }; - RibbonRecoveryCallback recoveryCallback = new RibbonRecoveryCallback() { + LoadBalancedRecoveryCallback recoveryCallback = new LoadBalancedRecoveryCallback() { @Override protected RibbonApacheHttpResponse createResponse(HttpResponse response, URI uri) { return new RibbonApacheHttpResponse(response, uri); @@ -164,9 +125,9 @@ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingH boolean retryable = isRequestRetryable(request); retryTemplate.setRetryPolicy(retryPolicy == null || !retryable ? new NeverRetryPolicy() : new RetryPolicy(request, retryPolicy, this, this.getClientName())); - BackOffPolicy backOffPolicy = loadBalancedBackOffPolicyFactory.createBackOffPolicy(this.getClientName()); + BackOffPolicy backOffPolicy = loadBalancedRetryFactory.createBackOffPolicy(this.getClientName()); retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy); - RetryListener[] retryListeners = this.loadBalancedRetryListenerFactory.createRetryListeners(this.getClientName()); + RetryListener[] retryListeners = this.loadBalancedRetryFactory.createRetryListeners(this.getClientName()); if (retryListeners != null && retryListeners.length != 0) { retryTemplate.setListeners(retryListeners); } diff --git a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/OkHttpRibbonConfiguration.java b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/OkHttpRibbonConfiguration.java index d3e5d3fb1..2bc386d59 100644 --- a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/OkHttpRibbonConfiguration.java +++ b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/OkHttpRibbonConfiguration.java @@ -25,9 +25,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; -import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.commons.httpclient.OkHttpClientConnectionPoolFactory; import org.springframework.cloud.commons.httpclient.OkHttpClientFactory; import org.springframework.cloud.netflix.ribbon.RibbonClientName; @@ -101,12 +99,10 @@ public class OkHttpRibbonConfiguration { ServerIntrospector serverIntrospector, ILoadBalancer loadBalancer, RetryHandler retryHandler, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, - OkHttpClient delegate, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory, - LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) { + LoadBalancedRetryFactory loadBalancedRetryFactory, + OkHttpClient delegate) { RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient(delegate, config, - serverIntrospector, loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory); + serverIntrospector, loadBalancedRetryFactory); client.setLoadBalancer(loadBalancer); client.setRetryHandler(retryHandler); Monitors.registerObject("Client_" + this.name, client); diff --git a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/RetryableOkHttpLoadBalancingClient.java b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/RetryableOkHttpLoadBalancingClient.java index b62d5c541..13a76156e 100644 --- a/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/RetryableOkHttpLoadBalancingClient.java +++ b/spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/RetryableOkHttpLoadBalancingClient.java @@ -24,12 +24,10 @@ import java.net.URI; import org.apache.commons.lang.BooleanUtils; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.loadbalancer.InterceptorRetryPolicy; -import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRecoveryCallback; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; -import org.springframework.cloud.client.loadbalancer.RibbonRecoveryCallback; import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser; import org.springframework.cloud.netflix.ribbon.support.ContextAwareRequest; import org.springframework.http.HttpRequest; @@ -56,38 +54,12 @@ import com.netflix.loadbalancer.Server; */ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClient implements ServiceInstanceChooser { - private LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory; - private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory = - new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory = - new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); - - @Deprecated - //TODO remove in 2.0.x - public RetryableOkHttpLoadBalancingClient(OkHttpClient delegate, IClientConfig config, ServerIntrospector serverIntrospector, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory) { - super(delegate, config, serverIntrospector); - this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory; - } - - @Deprecated - //TODO remove in 2.0.x - public RetryableOkHttpLoadBalancingClient(OkHttpClient delegate, IClientConfig config, ServerIntrospector serverIntrospector, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) { - super(delegate, config, serverIntrospector); - this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory; - this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory; - } + private LoadBalancedRetryFactory loadBalancedRetryFactory; public RetryableOkHttpLoadBalancingClient(OkHttpClient delegate, IClientConfig config, ServerIntrospector serverIntrospector, - LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory, - LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) { + LoadBalancedRetryFactory loadBalancedRetryPolicyFactory) { super(delegate, config, serverIntrospector); - this.loadBalancedRetryPolicyFactory = loadBalancedRetryPolicyFactory; - this.loadBalancedBackOffPolicyFactory = loadBalancedBackOffPolicyFactory; - this.loadBalancedRetryListenerFactory = loadBalancedRetryListenerFactory; + this.loadBalancedRetryFactory = loadBalancedRetryPolicyFactory; } @Override @@ -104,9 +76,9 @@ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClien RetryCallback callback, RecoveryCallback recoveryCallback) throws Exception { RetryTemplate retryTemplate = new RetryTemplate(); - BackOffPolicy backOffPolicy = loadBalancedBackOffPolicyFactory.createBackOffPolicy(this.getClientName()); + BackOffPolicy backOffPolicy = loadBalancedRetryFactory.createBackOffPolicy(this.getClientName()); retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy); - RetryListener[] retryListeners = this.loadBalancedRetryListenerFactory.createRetryListeners(this.getClientName()); + RetryListener[] retryListeners = this.loadBalancedRetryFactory.createRetryListeners(this.getClientName()); if (retryListeners != null && retryListeners.length != 0) { retryTemplate.setListeners(retryListeners); } @@ -119,7 +91,7 @@ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClien @Override public OkHttpRibbonResponse execute(final OkHttpRibbonRequest ribbonRequest, final IClientConfig configOverride) throws Exception { - final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryPolicyFactory.create(this.getClientName(), this); + final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory.createRetryPolicy(this.getClientName(), this); RetryCallback retryCallback = new RetryCallback() { @Override public OkHttpRibbonResponse doWithRetry(RetryContext context) throws Exception { @@ -154,7 +126,7 @@ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClien return new OkHttpRibbonResponse(response, newRequest.getUri()); } }; - return this.executeWithRetry(ribbonRequest, retryPolicy, retryCallback, new RibbonRecoveryCallback(){ + return this.executeWithRetry(ribbonRequest, retryPolicy, retryCallback, new LoadBalancedRecoveryCallback(){ @Override protected OkHttpRibbonResponse createResponse(Response response, URI uri) { diff --git a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTests.java b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryFactoryTests.java similarity index 92% rename from spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTests.java rename to spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryFactoryTests.java index 25fca70cd..b032e24f7 100644 --- a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryPolicyFactoryTests.java +++ b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonLoadBalancedRetryFactoryTests.java @@ -57,7 +57,7 @@ import static org.mockito.Mockito.verify; /** * @author Ryan Baxter */ -public class RibbonLoadBalancedRetryPolicyFactoryTests { +public class RibbonLoadBalancedRetryFactoryTests { @Mock private SpringClientFactory clientFactory; @@ -107,8 +107,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests { 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); + RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client); HttpRequest request = mock(HttpRequest.class); doReturn(HttpMethod.GET).when(request).getMethod(); LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request); @@ -135,8 +135,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests { 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); + RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client); HttpRequest request = mock(HttpRequest.class); doReturn(HttpMethod.POST).when(request).getMethod(); LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request); @@ -163,8 +163,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests { 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); + RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client); HttpRequest request = mock(HttpRequest.class); doReturn(HttpMethod.POST).when(request).getMethod(); LoadBalancedRetryContext context = new LoadBalancedRetryContext(null, request); @@ -186,8 +186,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests { doReturn("").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq("")); clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config)); RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server); - RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); - LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client); + RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client); HttpRequest request = mock(HttpRequest.class); doReturn(HttpMethod.GET).when(request).getMethod(); LoadBalancedRetryContext context = spy(new LoadBalancedRetryContext(null, request)); @@ -232,8 +232,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests { clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config)); RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server); - RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); - LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client); + RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client); HttpRequest request = mock(HttpRequest.class); LoadBalancedRetryContext context = spy(new LoadBalancedRetryContext(null, request)); @@ -260,8 +260,8 @@ public class RibbonLoadBalancedRetryPolicyFactoryTests { doReturn("404, 418,502,foo, ,").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq("")); clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config)); RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server); - RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); - LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client); + RibbonLoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory); + LoadBalancedRetryPolicy policy = factory.createRetryPolicy(server.getServiceId(), client); HttpRequest request = mock(HttpRequest.class); doReturn(HttpMethod.GET).when(request).getMethod(); assertThat(policy.retryableStatusCode(400), is(false)); diff --git a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java index 05fa3441e..c9f112c80 100644 --- a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java +++ b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryDisabledTests.java @@ -23,7 +23,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.test.context.runner.ApplicationContextRunner; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; import org.springframework.cloud.netflix.ribbon.apache.RibbonLoadBalancingHttpClient; import org.springframework.cloud.test.ClassPathExclusions; @@ -48,9 +48,8 @@ public class SpringRetryDisabledTests { LoadBalancerAutoConfiguration.class, RibbonClientConfiguration.class)) .run(context -> { - Map factories = context.getBeansOfType(LoadBalancedRetryPolicyFactory.class); - assertThat(factories.values(), hasSize(1)); - assertThat(factories.values().toArray()[0], instanceOf(LoadBalancedRetryPolicyFactory.NeverRetryFactory.class)); + Map factories = context.getBeansOfType(LoadBalancedRetryFactory.class); + assertThat(factories.values(), hasSize(0)); Map clients = context.getBeansOfType(RibbonLoadBalancingHttpClient.class); assertThat(clients.values(), hasSize(1)); assertThat(clients.values().toArray()[0], instanceOf(RibbonLoadBalancingHttpClient.class)); diff --git a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java index 1c66f951a..2854ad3f4 100644 --- a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java +++ b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/SpringRetryEnabledTests.java @@ -22,7 +22,8 @@ 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.LoadBalancedRetryFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; import org.springframework.cloud.commons.httpclient.HttpClientConfiguration; import org.springframework.cloud.netflix.ribbon.apache.RetryableRibbonLoadBalancingHttpClient; @@ -48,9 +49,9 @@ public class SpringRetryEnabledTests implements ApplicationContextAware { @Test public void testLoadBalancedRetryFactoryBean() throws Exception { - Map factories = context.getBeansOfType(LoadBalancedRetryPolicyFactory.class); + Map factories = context.getBeansOfType(LoadBalancedRetryFactory.class); assertThat(factories.values(), hasSize(1)); - assertThat(factories.values().toArray()[0], instanceOf(RibbonLoadBalancedRetryPolicyFactory.class)); + assertThat(factories.values().toArray()[0], instanceOf(RibbonLoadBalancedRetryFactory.class)); Map clients = context.getBeansOfType(RibbonLoadBalancingHttpClient.class); assertThat(clients.values(), hasSize(1)); assertThat(clients.values().toArray()[0], instanceOf(RetryableRibbonLoadBalancingHttpClient.class)); diff --git a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/apache/RibbonLoadBalancingHttpClientTests.java b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/apache/RibbonLoadBalancingHttpClientTests.java index f42ccebb0..9e0088d82 100644 --- a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/apache/RibbonLoadBalancingHttpClientTests.java +++ b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/apache/RibbonLoadBalancingHttpClientTests.java @@ -39,13 +39,11 @@ import org.mockito.ArgumentCaptor; import org.mockito.ArgumentMatcher; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; -import org.springframework.cloud.client.loadbalancer.LoadBalancedBackOffPolicyFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryListenerFactory; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.commons.httpclient.HttpClientConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicy; -import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory; +import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerContext; import org.springframework.cloud.netflix.ribbon.ServerIntrospector; import org.springframework.cloud.netflix.ribbon.SpringClientFactory; @@ -97,8 +95,6 @@ import static org.mockito.Mockito.when; public class RibbonLoadBalancingHttpClientTests { private ILoadBalancer loadBalancer; - private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory = new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); @Before public void setup() { @@ -250,9 +246,9 @@ public class RibbonLoadBalancingHttpClientTests { doReturn(locale).when(fourOFourResponse).getLocale(); doReturn(fourOFourResponse).when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "404", myBackOffPolicyFactory); + serviceName, host, port, delegate, lb, "404", myBackOffPolicy); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(uri).when(request).getURI(); doReturn(method).when(request).getMethod(); @@ -272,16 +268,16 @@ public class RibbonLoadBalancingHttpClientTests { boolean retryable, boolean retryOnAllOps, String serviceName, String host, int port, CloseableHttpClient delegate, ILoadBalancer lb, String statusCodes, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory) throws Exception { + BackOffPolicy backOffPolicy) throws Exception { return setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, serviceName, host, port, - delegate, lb, statusCodes, loadBalancedBackOffPolicyFactory, false); + delegate, lb, statusCodes, backOffPolicy, false); } private RetryableRibbonLoadBalancingHttpClient setupClientForRetry(int retriesNextServer, int retriesSameServer, boolean retryable, boolean retryOnAllOps, String serviceName, String host, int port, CloseableHttpClient delegate, ILoadBalancer lb, String statusCodes, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory, + BackOffPolicy backOffPolicy, boolean isSecure) throws Exception { ServerIntrospector introspector = mock(ServerIntrospector.class); RetryHandler retryHandler = new DefaultLoadBalancerRetryHandler(retriesSameServer, retriesNextServer, retryable); @@ -297,9 +293,14 @@ public class RibbonLoadBalancingHttpClientTests { SpringClientFactory clientFactory = mock(SpringClientFactory.class); doReturn(context).when(clientFactory).getLoadBalancerContext(eq(serviceName)); doReturn(clientConfig).when(clientFactory).getClientConfig(eq(serviceName)); - LoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); + LoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory) { + @Override + public BackOffPolicy createBackOffPolicy(String service) { + return backOffPolicy; + } + }; RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(delegate, clientConfig, - introspector, factory, loadBalancedBackOffPolicyFactory, new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory()); + introspector, factory); client.setLoadBalancer(lb); ReflectionTestUtils.setField(client, "delegate", delegate); return client; @@ -309,8 +310,8 @@ public class RibbonLoadBalancingHttpClientTests { boolean retryable, boolean retryOnAllOps, String serviceName, String host, int port, CloseableHttpClient delegate, ILoadBalancer lb, String statusCodes, - LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory, - boolean isSecure, LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) throws Exception { + BackOffPolicy backOffPolicy, + boolean isSecure, RetryListener[] retryListeners) throws Exception { ServerIntrospector introspector = mock(ServerIntrospector.class); RetryHandler retryHandler = new DefaultLoadBalancerRetryHandler(retriesSameServer, retriesNextServer, retryable); doReturn(new Server(host, port)).when(lb).chooseServer(eq(serviceName)); @@ -325,9 +326,19 @@ public class RibbonLoadBalancingHttpClientTests { SpringClientFactory clientFactory = mock(SpringClientFactory.class); doReturn(context).when(clientFactory).getLoadBalancerContext(eq(serviceName)); doReturn(clientConfig).when(clientFactory).getClientConfig(eq(serviceName)); - LoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory); + LoadBalancedRetryFactory factory = new RibbonLoadBalancedRetryFactory(clientFactory) { + @Override + public RetryListener[] createRetryListeners(String service) { + return retryListeners; + } + + @Override + public BackOffPolicy createBackOffPolicy(String service) { + return backOffPolicy; + } + }; RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(delegate, clientConfig, - introspector, factory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory); + introspector, factory); client.setLoadBalancer(lb); ReflectionTestUtils.setField(client, "delegate", delegate); return client; @@ -352,7 +363,7 @@ public class RibbonLoadBalancingHttpClientTests { doThrow(new IOException("boom")).doReturn(response).when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", loadBalancedBackOffPolicyFactory); + serviceName, host, port, delegate, lb, "", null); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(uri).when(request).getURI(); doReturn(method).when(request).getMethod(); @@ -384,9 +395,9 @@ public class RibbonLoadBalancingHttpClientTests { doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response). when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory); + serviceName, host, port, delegate, lb, "", myBackOffPolicy); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(uri).when(request).getURI(); doReturn(method).when(request).getMethod(); @@ -397,7 +408,7 @@ public class RibbonLoadBalancingHttpClientTests { client.execute(request, null); verify(delegate, times(3)).execute(any(HttpUriRequest.class)); verify(lb, times(2)).chooseServer(eq(serviceName)); - assertEquals(2, myBackOffPolicyFactory.getCount()); + assertEquals(2, myBackOffPolicy.getCount()); } @Test @@ -419,9 +430,9 @@ public class RibbonLoadBalancingHttpClientTests { doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response). when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory); + serviceName, host, port, delegate, lb, "", myBackOffPolicy); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(method).when(request).getMethod(); doReturn(uri).when(request).getURI(); @@ -432,7 +443,7 @@ public class RibbonLoadBalancingHttpClientTests { verify(response, times(0)).close(); verify(delegate, times(3)).execute(any(HttpUriRequest.class)); verify(lb, times(2)).chooseServer(eq(serviceName)); - assertEquals(2, myBackOffPolicyFactory.getCount()); + assertEquals(2, myBackOffPolicy.getCount()); } @Test @@ -497,7 +508,7 @@ public class RibbonLoadBalancingHttpClientTests { when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", loadBalancedBackOffPolicyFactory,true); + serviceName, host, port, delegate, lb, "", null,true); client.execute(request, null); verify(response, times(0)).close(); verify(delegate, times(1)).execute(argThat(new ArgumentMatcher() { @@ -529,7 +540,7 @@ public class RibbonLoadBalancingHttpClientTests { when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", loadBalancedBackOffPolicyFactory); + serviceName, host, port, delegate, lb, "", null); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(method).when(request).getMethod(); doReturn(uri).when(request).getURI(); @@ -576,9 +587,9 @@ public class RibbonLoadBalancingHttpClientTests { doReturn(fourOFourStatusLine).when(fourOFourResponse).getStatusLine(); doReturn(fourOFourResponse).doReturn(response).when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "404", myBackOffPolicyFactory); + serviceName, host, port, delegate, lb, "404", myBackOffPolicy); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(uri).when(request).getURI(); doReturn(method).when(request).getMethod(); @@ -590,7 +601,7 @@ public class RibbonLoadBalancingHttpClientTests { verify(fourOFourResponse, times(1)).close(); verify(delegate, times(2)).execute(any(HttpUriRequest.class)); verify(lb, times(1)).chooseServer(eq(serviceName)); - assertEquals(1, myBackOffPolicyFactory.getCount()); + assertEquals(1, myBackOffPolicy.getCount()); } @Test @@ -612,10 +623,10 @@ public class RibbonLoadBalancingHttpClientTests { doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response). when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); - MyRetryListeners myRetryListeners = new MyRetryListeners(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); + MyRetryListener myRetryListener = new MyRetryListener(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false, myRetryListeners); + serviceName, host, port, delegate, lb, "", myBackOffPolicy, false, new RetryListener[]{myRetryListener}); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(method).when(request).getMethod(); doReturn(uri).when(request).getURI(); @@ -626,8 +637,8 @@ public class RibbonLoadBalancingHttpClientTests { verify(response, times(0)).close(); verify(delegate, times(3)).execute(any(HttpUriRequest.class)); verify(lb, times(2)).chooseServer(eq(serviceName)); - assertEquals(2, myBackOffPolicyFactory.getCount()); - assertEquals(2, myRetryListeners.getOnError()); + assertEquals(2, myBackOffPolicy.getCount()); + assertEquals(2, myRetryListener.getOnError()); } @Test @@ -649,10 +660,10 @@ public class RibbonLoadBalancingHttpClientTests { doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response). when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); - MyRetryListeners myRetryListeners = new MyRetryListeners(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); + MyRetryListener myRetryListener = new MyRetryListener(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false, loadBalancedRetryListenerFactory); + serviceName, host, port, delegate, lb, "", myBackOffPolicy, false, new RetryListener[]{}); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(method).when(request).getMethod(); doReturn(uri).when(request).getURI(); @@ -663,8 +674,8 @@ public class RibbonLoadBalancingHttpClientTests { verify(response, times(0)).close(); verify(delegate, times(3)).execute(any(HttpUriRequest.class)); verify(lb, times(2)).chooseServer(eq(serviceName)); - assertEquals(2, myBackOffPolicyFactory.getCount()); - assertEquals(0, myRetryListeners.getOnError()); + assertEquals(2, myBackOffPolicy.getCount()); + assertEquals(0, myRetryListener.getOnError()); } @Test(expected = TerminatedRetryException.class) @@ -686,10 +697,10 @@ public class RibbonLoadBalancingHttpClientTests { doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response). when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); - MyRetryListenersNotRetry myRetryListenersNotRetry = new MyRetryListenersNotRetry(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); + MyRetryListenerNotRetry myRetryListenerNotRetry = new MyRetryListenerNotRetry(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false, myRetryListenersNotRetry); + serviceName, host, port, delegate, lb, "", myBackOffPolicy, false, new RetryListener[]{myRetryListenerNotRetry}); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(method).when(request).getMethod(); doReturn(uri).when(request).getURI(); @@ -719,9 +730,9 @@ public class RibbonLoadBalancingHttpClientTests { doThrow(new IOException("boom")).doThrow(new IOException("boom again")).doReturn(response). when(delegate).execute(any(HttpUriRequest.class)); ILoadBalancer lb = mock(ILoadBalancer.class); - MyBackOffPolicyFactory myBackOffPolicyFactory = new MyBackOffPolicyFactory(); + MyBackOffPolicy myBackOffPolicy = new MyBackOffPolicy(); RetryableRibbonLoadBalancingHttpClient client = setupClientForRetry(retriesNextServer, retriesSameServer, retryable, retryOnAllOps, - serviceName, host, port, delegate, lb, "", myBackOffPolicyFactory, false); + serviceName, host, port, delegate, lb, "", myBackOffPolicy, false); RibbonApacheHttpRequest request = mock(RibbonApacheHttpRequest.class); doReturn(method).when(request).getMethod(); doReturn(uri).when(request).getURI(); @@ -732,7 +743,7 @@ public class RibbonLoadBalancingHttpClientTests { verify(response, times(0)).close(); verify(delegate, times(3)).execute(any(HttpUriRequest.class)); verify(lb, times(2)).chooseServer(eq(serviceName)); - assertEquals(2, myBackOffPolicyFactory.getCount()); + assertEquals(2, myBackOffPolicy.getCount()); } @Configuration @@ -824,7 +835,7 @@ public class RibbonLoadBalancingHttpClientTests { return requestConfigCaptor.getValue(); } - class MyBackOffPolicyFactory implements LoadBalancedBackOffPolicyFactory, BackOffPolicy { + class MyBackOffPolicy implements BackOffPolicy { private int count = 0; @@ -841,62 +852,47 @@ public class RibbonLoadBalancingHttpClientTests { int getCount() { return count; } - - @Override - public BackOffPolicy createBackOffPolicy(String service) { - return this; - } } - class MyRetryListeners implements LoadBalancedRetryListenerFactory { + class MyRetryListener implements RetryListener { private int onError = 0; - @Override - public RetryListener[] createRetryListeners(String service) { - return new RetryListener[] {new RetryListener() { - @Override - public boolean open(RetryContext context, RetryCallback callback) { - return true; - } - - @Override - public void close(RetryContext context, RetryCallback callback, Throwable throwable) { - - } - - @Override - public void onError(RetryContext context, RetryCallback callback, Throwable throwable) { - onError++; - } - }}; - } - int getOnError() { return onError; } - } - - class MyRetryListenersNotRetry implements LoadBalancedRetryListenerFactory { @Override - public RetryListener[] createRetryListeners(String service) { - return new RetryListener[] {new RetryListener() { - @Override - public boolean open(RetryContext context, RetryCallback callback) { - return false; - } + public boolean open(RetryContext context, RetryCallback callback) { + return true; + } - @Override - public void close(RetryContext context, RetryCallback callback, Throwable throwable) { + @Override + public void close(RetryContext context, RetryCallback callback, Throwable throwable) { - } + } - @Override - public void onError(RetryContext context, RetryCallback callback, Throwable throwable) { + @Override + public void onError(RetryContext context, RetryCallback callback, Throwable throwable) { + onError++; + } + } + + class MyRetryListenerNotRetry implements RetryListener { + + @Override + public boolean open(RetryContext context, RetryCallback callback) { + return false; + } + + @Override + public void close(RetryContext context, RetryCallback callback, Throwable throwable) { + + } + + @Override + public void onError(RetryContext context, RetryCallback callback, Throwable throwable) { - } - }}; } } diff --git a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryDisableOkHttpClientTests.java b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryDisableOkHttpClientTests.java index c78e740af..263a412d8 100644 --- a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryDisableOkHttpClientTests.java +++ b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryDisableOkHttpClientTests.java @@ -22,7 +22,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.test.context.runner.ApplicationContextRunner; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; import org.springframework.cloud.commons.httpclient.HttpClientConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration; @@ -52,9 +52,8 @@ public class SpringRetryDisableOkHttpClientTests { .withUserConfiguration( OkHttpLoadBalancingClientTests.OkHttpClientConfiguration.class) .run(context -> { - Map factories = context.getBeansOfType(LoadBalancedRetryPolicyFactory.class); - assertThat(factories.values(), hasSize(1)); - assertThat(factories.values().toArray()[0], instanceOf(LoadBalancedRetryPolicyFactory.NeverRetryFactory.class)); + Map factories = context.getBeansOfType(LoadBalancedRetryFactory.class); + assertThat(factories.values(), hasSize(0)); Map clients = context.getBeansOfType(OkHttpLoadBalancingClient.class); assertThat(clients.values(), hasSize(1)); assertThat(clients.values().toArray()[0], instanceOf(OkHttpLoadBalancingClient.class)); diff --git a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryEnabledOkHttpClientTests.java b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryEnabledOkHttpClientTests.java index 2cf328d3d..f2d23e670 100644 --- a/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryEnabledOkHttpClientTests.java +++ b/spring-cloud-netflix-ribbon/src/test/java/org/springframework/cloud/netflix/ribbon/okhttp/SpringRetryEnabledOkHttpClientTests.java @@ -20,12 +20,12 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.BeansException; import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; import org.springframework.cloud.commons.httpclient.HttpClientConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration; -import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory; +import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.test.context.ContextConfiguration; @@ -49,11 +49,11 @@ public class SpringRetryEnabledOkHttpClientTests implements ApplicationContextAw @Test public void testLoadBalancedRetryFactoryBean() throws Exception { - Map factories = context - .getBeansOfType(LoadBalancedRetryPolicyFactory.class); + Map factories = context + .getBeansOfType(LoadBalancedRetryFactory.class); assertThat(factories.values(), hasSize(1)); assertThat(factories.values().toArray()[0], - instanceOf(RibbonLoadBalancedRetryPolicyFactory.class)); + instanceOf(RibbonLoadBalancedRetryFactory.class)); Map clients = context .getBeansOfType(OkHttpLoadBalancingClient.class); assertThat(clients.values(), hasSize(1)); diff --git a/spring-cloud-netflix-zuul/src/test/java/org/springframework/cloud/netflix/zuul/filters/route/support/RibbonRetryIntegrationTestBase.java b/spring-cloud-netflix-zuul/src/test/java/org/springframework/cloud/netflix/zuul/filters/route/support/RibbonRetryIntegrationTestBase.java index a0d1eea63..32dfca60c 100644 --- a/spring-cloud-netflix-zuul/src/test/java/org/springframework/cloud/netflix/zuul/filters/route/support/RibbonRetryIntegrationTestBase.java +++ b/spring-cloud-netflix-zuul/src/test/java/org/springframework/cloud/netflix/zuul/filters/route/support/RibbonRetryIntegrationTestBase.java @@ -30,13 +30,13 @@ import org.junit.Test; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.web.client.TestRestTemplate; +import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory; import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy; -import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory; import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser; import org.springframework.cloud.netflix.ribbon.RibbonClient; import org.springframework.cloud.netflix.ribbon.RibbonClients; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicy; -import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory; +import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerContext; import org.springframework.cloud.netflix.ribbon.SpringClientFactory; import org.springframework.cloud.netflix.ribbon.StaticServerList; @@ -210,23 +210,23 @@ public abstract class RibbonRetryIntegrationTestBase { extends RibbonClientConfiguration { @Bean - public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory( + public LoadBalancedRetryFactory loadBalancedRetryPolicyFactory( SpringClientFactory factory) { - return new MyRibbonRetryPolicyFactory(factory); + return new MyRibbonRetryFactory(factory); } - public static class MyRibbonRetryPolicyFactory - extends RibbonLoadBalancedRetryPolicyFactory { + public static class MyRibbonRetryFactory + extends RibbonLoadBalancedRetryFactory { private SpringClientFactory factory; - public MyRibbonRetryPolicyFactory(SpringClientFactory clientFactory) { + public MyRibbonRetryFactory(SpringClientFactory clientFactory) { super(clientFactory); this.factory = clientFactory; } @Override - public LoadBalancedRetryPolicy create(String serviceId, + public LoadBalancedRetryPolicy createRetryPolicy(String serviceId, ServiceInstanceChooser loadBalanceChooser) { RibbonLoadBalancerContext lbContext = this.factory .getLoadBalancerContext(serviceId);