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 0c7f6d237..ea73014f5 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 @@ -15,7 +15,6 @@ */ package org.springframework.cloud.netflix.ribbon.apache; -import java.io.IOException; import java.net.URI; import org.apache.commons.lang.BooleanUtils; import org.apache.http.HttpResponse; @@ -23,15 +22,12 @@ 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; import org.springframework.cloud.netflix.ribbon.RibbonProperties; import org.springframework.cloud.netflix.ribbon.ServerIntrospector; import org.springframework.cloud.netflix.ribbon.support.ContextAwareRequest; @@ -45,11 +41,9 @@ import org.springframework.retry.policy.NeverRetryPolicy; import org.springframework.retry.support.RetryTemplate; import org.springframework.web.util.UriComponentsBuilder; -import com.netflix.client.ClientException; import com.netflix.client.RequestSpecificRetryHandler; import com.netflix.client.RetryHandler; import com.netflix.client.config.IClientConfig; -import com.netflix.loadbalancer.Server; /** * An Apache HTTP client which leverages Spring Retry to retry failed requests. @@ -57,50 +51,13 @@ import com.netflix.loadbalancer.Server; * @author Gang Li */ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingHttpClient { - 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 @@ -113,14 +70,15 @@ 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 -> { + RetryCallback retryCallback = context -> { //on retries the policy will choose the server and set it in the context //extract the server and update the request being made RibbonApacheHttpRequest newRequest = request; if (context instanceof LoadBalancedRetryContext) { ServiceInstance service = ((LoadBalancedRetryContext) context).getServiceInstance(); + validateServiceInstance(service); if (service != null) { //Reconstruct the request URI using the host and port set in the retry context newRequest = newRequest.withNewUri(UriComponentsBuilder.newInstance().host(service.getHost()) @@ -139,7 +97,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); @@ -165,9 +123,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 001273862..885c6a859 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; @@ -55,38 +53,12 @@ import com.netflix.client.config.IClientConfig; */ public class RetryableOkHttpLoadBalancingClient extends OkHttpLoadBalancingClient { - 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 @@ -103,9 +75,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); } @@ -118,7 +90,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 { @@ -152,7 +124,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 5c3b78e2b..2c72498fb 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; @@ -100,8 +98,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() { @@ -253,9 +249,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(); @@ -275,16 +271,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); @@ -300,9 +296,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; @@ -312,8 +313,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)); @@ -328,9 +329,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; @@ -355,7 +366,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(); @@ -387,9 +398,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(); @@ -400,7 +411,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 @@ -422,9 +433,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(); @@ -435,7 +446,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 @@ -500,7 +511,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() { @@ -532,7 +543,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(); @@ -579,9 +590,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(); @@ -593,7 +604,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 @@ -615,10 +626,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(); @@ -629,8 +640,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 @@ -652,10 +663,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(); @@ -666,8 +677,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) @@ -689,10 +700,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(); @@ -722,9 +733,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(); @@ -735,7 +746,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()); } private RetryableRibbonLoadBalancingHttpClient setupClientForServerValidation(String serviceName, String host, int port, @@ -753,9 +764,9 @@ 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); RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(delegate, - clientConfig, introspector, factory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory); + clientConfig, introspector, factory); client.setLoadBalancer(lb); ReflectionTestUtils.setField(client, "delegate", delegate); return client; @@ -902,7 +913,7 @@ public class RibbonLoadBalancingHttpClientTests { return requestConfigCaptor.getValue(); } - class MyBackOffPolicyFactory implements LoadBalancedBackOffPolicyFactory, BackOffPolicy { + class MyBackOffPolicy implements BackOffPolicy { private int count = 0; @@ -919,62 +930,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 d48bf11f7..276a340bd 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 @@ -15,32 +15,22 @@ */ package org.springframework.cloud.netflix.ribbon.okhttp; -import static org.hamcrest.CoreMatchers.containsString; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.Assert.fail; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.eq; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; +import okhttp3.OkHttpClient; +import okhttp3.Request; import java.net.URI; import java.util.Map; - 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.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.commons.httpclient.HttpClientConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration; +import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryFactory; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicy; -import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancedRetryPolicyFactory; import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerContext; import org.springframework.cloud.netflix.ribbon.ServerIntrospector; import org.springframework.cloud.netflix.ribbon.SpringClientFactory; @@ -50,7 +40,6 @@ import org.springframework.http.HttpMethod; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.util.ReflectionTestUtils; - import com.netflix.client.ClientException; import com.netflix.client.DefaultLoadBalancerRetryHandler; import com.netflix.client.RetryHandler; @@ -59,8 +48,15 @@ import com.netflix.client.config.DefaultClientConfigImpl; import com.netflix.loadbalancer.ILoadBalancer; import com.netflix.loadbalancer.Server; -import okhttp3.OkHttpClient; -import okhttp3.Request; +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +import static org.junit.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; /** * @author Ryan Baxter @@ -74,16 +70,14 @@ public class SpringRetryEnabledOkHttpClientTests implements ApplicationContextAw private ApplicationContext context; private ILoadBalancer loadBalancer; - private LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory = new LoadBalancedBackOffPolicyFactory.NoBackOffPolicyFactory(); - private LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory = new LoadBalancedRetryListenerFactory.DefaultRetryListenerFactory(); @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)); @@ -111,9 +105,9 @@ public class SpringRetryEnabledOkHttpClientTests implements ApplicationContextAw 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); RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient(delegate, clientConfig, introspector, - factory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory); + factory); client.setLoadBalancer(lb); ReflectionTestUtils.setField(client, "delegate", delegate); return client; 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);