SpringCloud/spring-cloud-commons
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename LoadBalanceChooser to ServiceInstanceChoose

Browse Source
This commit is contained in:
Ryan Baxter
2016-10-25 15:44:49 -04:00
parent 39045ee20e 65c00ecb93
commit b0dca4ee76
6 changed files with 30 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/InterceptorRetryPolicy.java
View File

@@ -27,21 +27,21 @@ public class InterceptorRetryPolicy implements RetryPolicy {
private HttpRequest request;
private LoadBalancedRetryPolicy policy;
private LoadBalanceChooser loadBalanceChooser;
private ServiceInstanceChooser serviceInstanceChooser;
private String serviceName;
/**
* Creates a new retry policy.
* @param request the request that will be retried
* @param policy the retry policy from the load balancer
* @param loadBalanceChooser the load balancer client
* @param serviceInstanceChooser the load balancer client
* @param serviceName the name of the service
*/
public InterceptorRetryPolicy(HttpRequest request, LoadBalancedRetryPolicy policy,
LoadBalanceChooser loadBalanceChooser, String serviceName) {
ServiceInstanceChooser serviceInstanceChooser, String serviceName) {
this.request = request;
this.policy = policy;
this.loadBalanceChooser = loadBalanceChooser;
this.serviceInstanceChooser = serviceInstanceChooser;
this.serviceName = serviceName;
}
@@ -50,7 +50,7 @@ public class InterceptorRetryPolicy implements RetryPolicy {
LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext)context;
if(lbContext.getRetryCount() == 0 && lbContext.getServiceInstance() == null) {
//We haven't even tried to make the request yet so return true so we do
lbContext.setServiceInstance(loadBalanceChooser.choose(serviceName));
lbContext.setServiceInstance(serviceInstanceChooser.choose(serviceName));
return true;
}
return policy.canRetryNextServer(lbContext);
@@ -86,7 +86,7 @@ public class InterceptorRetryPolicy implements RetryPolicy {
if (!request.equals(that.request)) return false;
if (!policy.equals(that.policy)) return false;
if (!loadBalanceChooser.equals(that.loadBalanceChooser)) return false;
if (!serviceInstanceChooser.equals(that.serviceInstanceChooser)) return false;
return serviceName.equals(that.serviceName);
}
@@ -95,7 +95,7 @@ public class InterceptorRetryPolicy implements RetryPolicy {
public int hashCode() {
int result = request.hashCode();
result = 31 * result + policy.hashCode();
result = 31 * result + loadBalanceChooser.hashCode();
result = 31 * result + serviceInstanceChooser.hashCode();
result = 31 * result + serviceName.hashCode();
return result;
}

6
spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancedRetryPolicyFactory.java
View File

@@ -24,15 +24,15 @@ public interface LoadBalancedRetryPolicyFactory {
/**
* Creates a {@link LoadBalancedRetryPolicy}.
* @param serviceId The ID of the service to create the retry policy for.
* @param loadBalanceChooser Used to get the next server from a load balancer
* @param serviceInstanceChooser Used to get the next server from a load balancer
* @return A retry policy for the service.
*/
public LoadBalancedRetryPolicy create(String serviceId, LoadBalanceChooser loadBalanceChooser);
public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser serviceInstanceChooser);
static class NeverRetryFactory implements LoadBalancedRetryPolicyFactory {
@Override
public LoadBalancedRetryPolicy create(String serviceId, LoadBalanceChooser loadBalanceChooser) {
public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser serviceInstanceChooser) {
return null;
}
}

2
spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerClient.java
View File

@@ -25,7 +25,7 @@ import java.net.URI;
* Represents a client side load balancer
* @author Spencer Gibb
*/
public interface LoadBalancerClient extends LoadBalanceChooser {
public interface LoadBalancerClient extends ServiceInstanceChooser {
/**
* execute request using a ServiceInstance from the LoadBalancer for the specified

2
spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalanceChooser.java → spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/ServiceInstanceChooser.java
View File

@@ -24,7 +24,7 @@ import org.springframework.cloud.client.ServiceInstance;
*
* @author Ryan Baxter
*/
public interface LoadBalanceChooser {
public interface ServiceInstanceChooser {
/**
* Choose a ServiceInstance from the LoadBalancer for the specified service

26
spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/InterceptorRetryPolicyTest.java
View File

@@ -26,14 +26,14 @@ public class InterceptorRetryPolicyTest {
private HttpRequest request;
private LoadBalancedRetryPolicy policy;
private LoadBalanceChooser loadBalanceChooser;
private ServiceInstanceChooser serviceInstanceChooser;
private String serviceName;
@Before
public void setup() {
request = mock(HttpRequest.class);
policy = mock(LoadBalancedRetryPolicy.class);
loadBalanceChooser = mock(LoadBalanceChooser.class);
serviceInstanceChooser = mock(ServiceInstanceChooser.class);
serviceName = "foo";
}
@@ -41,17 +41,17 @@ public class InterceptorRetryPolicyTest {
public void teardown() {
request = null;
policy = null;
loadBalanceChooser = null;
serviceInstanceChooser = null;
serviceName = null;
}
@Test
public void canRetryBeforeExecution() throws Exception {
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName);
LoadBalancedRetryContext context = mock(LoadBalancedRetryContext.class);
when(context.getRetryCount()).thenReturn(0);
ServiceInstance serviceInstance = mock(ServiceInstance.class);
when(loadBalanceChooser.choose(eq(serviceName))).thenReturn(serviceInstance);
when(serviceInstanceChooser.choose(eq(serviceName))).thenReturn(serviceInstance);
assertThat(interceptorRetryPolicy.canRetry(context), is(true));
verify(context, times(1)).setServiceInstance(eq(serviceInstance));
@@ -59,7 +59,7 @@ public class InterceptorRetryPolicyTest {
@Test
public void canRetryNextServer() throws Exception {
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName);
LoadBalancedRetryContext context = mock(LoadBalancedRetryContext.class);
when(context.getRetryCount()).thenReturn(1);
when(policy.canRetryNextServer(eq(context))).thenReturn(true);
@@ -68,7 +68,7 @@ public class InterceptorRetryPolicyTest {
@Test
public void cannotRetry() throws Exception {
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName);
LoadBalancedRetryContext context = mock(LoadBalancedRetryContext.class);
when(context.getRetryCount()).thenReturn(1);
assertThat(interceptorRetryPolicy.canRetry(context), is(false));
@@ -76,14 +76,14 @@ public class InterceptorRetryPolicyTest {
@Test
public void open() throws Exception {
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName);
RetryContext context = interceptorRetryPolicy.open(null);
assertThat(context, IsInstanceOf.instanceOf(LoadBalancedRetryContext.class));
}
@Test
public void close() throws Exception {
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName);
LoadBalancedRetryContext context = mock(LoadBalancedRetryContext.class);
interceptorRetryPolicy.close(context);
verify(policy, times(1)).close(eq(context));
@@ -91,13 +91,13 @@ public class InterceptorRetryPolicyTest {
@Test
public void registerThrowable() throws Exception {
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName);
LoadBalancedRetryContext context = mock(LoadBalancedRetryContext.class);
Throwable thrown = new Exception();
when(policy.canRetryNextServer(eq(context))).thenReturn(true);
when(policy.canRetrySameServer(eq(context))).thenReturn(false);
ServiceInstance serviceInstance = mock(ServiceInstance.class);
when(loadBalanceChooser.choose(eq(serviceName))).thenReturn(serviceInstance);
when(serviceInstanceChooser.choose(eq(serviceName))).thenReturn(serviceInstance);
interceptorRetryPolicy.registerThrowable(context, thrown);
verify(context, times(1)).registerThrowable(eq(thrown));
verify(policy, times(1)).registerThrowable(eq(context), eq(thrown));
@@ -105,11 +105,11 @@ public class InterceptorRetryPolicyTest {
@Test
public void equals() throws Exception {
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName);
assertThat(interceptorRetryPolicy.equals(null), is(false));
assertThat(interceptorRetryPolicy.equals(new Object()), is(false));
assertThat(interceptorRetryPolicy.equals(interceptorRetryPolicy), is(true));
assertThat(interceptorRetryPolicy.equals(new InterceptorRetryPolicy(request, policy, loadBalanceChooser, serviceName)), is(true));
assertThat(interceptorRetryPolicy.equals(new InterceptorRetryPolicy(request, policy, serviceInstanceChooser, serviceName)), is(true));
}
}

10
spring-cloud-commons/src/test/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptorTest.java
View File

@@ -57,7 +57,7 @@ public class RetryLoadBalancerInterceptorTest {
when(request.getURI()).thenReturn(new URI("http://foo"));
ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK);
LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class);
when(lbRetryPolicyFactory.create(eq("foo"), any(LoadBalanceChooser.class))).thenReturn(null);
when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(null);
ServiceInstance serviceInstance = mock(ServiceInstance.class);
when(client.choose(eq("foo"))).thenReturn(serviceInstance);
when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException());
@@ -75,7 +75,7 @@ public class RetryLoadBalancerInterceptorTest {
when(request.getURI()).thenReturn(new URI("http://foo"));
ClientHttpResponse clientHttpResponse = new MockClientHttpResponse(new byte[]{}, HttpStatus.OK);
LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class);
when(lbRetryPolicyFactory.create(eq("foo"), any(LoadBalanceChooser.class))).thenReturn(null);
when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(null);
ServiceInstance serviceInstance = mock(ServiceInstance.class);
when(client.choose(eq("foo"))).thenReturn(serviceInstance);
when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenReturn(clientHttpResponse);
@@ -95,7 +95,7 @@ public class RetryLoadBalancerInterceptorTest {
LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class);
InterceptorRetryPolicy interceptorRetryPolicy = new InterceptorRetryPolicy(request, policy, client,"foo");
LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class);
when(lbRetryPolicyFactory.create(eq("foo"), any(LoadBalanceChooser.class))).thenReturn(policy);
when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy);
ServiceInstance serviceInstance = mock(ServiceInstance.class);
when(client.choose(eq("foo"))).thenReturn(serviceInstance);
when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenReturn(clientHttpResponse);
@@ -116,7 +116,7 @@ public class RetryLoadBalancerInterceptorTest {
LoadBalancedRetryPolicy policy = mock(LoadBalancedRetryPolicy.class);
when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(true);
LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class);
when(lbRetryPolicyFactory.create(eq("foo"), any(LoadBalanceChooser.class))).thenReturn(policy);
when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy);
ServiceInstance serviceInstance = mock(ServiceInstance.class);
when(client.choose(eq("foo"))).thenReturn(serviceInstance);
when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException()).thenReturn(clientHttpResponse);
@@ -139,7 +139,7 @@ public class RetryLoadBalancerInterceptorTest {
when(policy.canRetrySameServer(any(LoadBalancedRetryContext.class))).thenReturn(false);
when(policy.canRetryNextServer(any(LoadBalancedRetryContext.class))).thenReturn(false);
LoadBalancedRetryPolicyFactory lbRetryPolicyFactory = mock(LoadBalancedRetryPolicyFactory.class);
when(lbRetryPolicyFactory.create(eq("foo"), any(LoadBalanceChooser.class))).thenReturn(policy);
when(lbRetryPolicyFactory.create(eq("foo"), any(ServiceInstanceChooser.class))).thenReturn(policy);
ServiceInstance serviceInstance = mock(ServiceInstance.class);
when(client.choose(eq("foo"))).thenReturn(serviceInstance);
when(client.execute(eq("foo"), eq(serviceInstance), any(LoadBalancerRequest.class))).thenThrow(new IOException()).thenReturn(clientHttpResponse);