grpc
/
grpc-java
mirror of https://github.com/grpc/grpc-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

lb: acceptResolvedAddresses() to return Status (#10636) 

Instead of a boolean, we now return a Status object. Status.OK
represents accepted addresses and other non-acceptance. This allows the
LB to provide more information about why a set of addresses were not
acceptable.

The status will later be sent to the name resolver as well to allow it
to also better react to to bad addresses.
This commit is contained in:
Terry Wilson 2023-11-03 09:02:46 -07:00 committed by GitHub
parent 4fbefe9f0f
commit 9888a54abd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 299 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
api/src/main/java/io/grpc/LoadBalancer.java
View File

@ -162,20 +162,21 @@ public abstract class LoadBalancer {
* @return {@code true} if the resolved addresses were accepted. {@code false} if rejected. * @return {@code true} if the resolved addresses were accepted. {@code false} if rejected.
* @since 1.49.0 * @since 1.49.0
*/ */
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
if (resolvedAddresses.getAddresses().isEmpty() if (resolvedAddresses.getAddresses().isEmpty()
&& !canHandleEmptyAddressListFromNameResolution()) { && !canHandleEmptyAddressListFromNameResolution()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses() "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes())); + ", attrs=" + resolvedAddresses.getAttributes());
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} else { } else {
if (recursionCount++ == 0) { if (recursionCount++ == 0) {
handleResolvedAddresses(resolvedAddresses); handleResolvedAddresses(resolvedAddresses);
} }
recursionCount = 0; recursionCount = 0;
return true; return Status.OK;
} }
} }

4
api/src/test/java/io/grpc/LoadBalancerTest.java
View File

@ -240,9 +240,9 @@ public class LoadBalancerTest {
LoadBalancer balancer = new LoadBalancer() { LoadBalancer balancer = new LoadBalancer() {
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
resultCapture.set(resolvedAddresses); resultCapture.set(resolvedAddresses);
return true; return Status.OK;
} }
@Override @Override

8
core/src/main/java/io/grpc/internal/AutoConfiguredLoadBalancerFactory.java
View File

@ -70,8 +70,8 @@ public final class AutoConfiguredLoadBalancerFactory {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return true; return Status.OK;
} }
@Override @Override
@ -102,7 +102,7 @@ public final class AutoConfiguredLoadBalancerFactory {
* Returns non-OK status if the delegate rejects the resolvedAddresses (e.g. if it does not * Returns non-OK status if the delegate rejects the resolvedAddresses (e.g. if it does not
* support an empty list). * support an empty list).
*/ */
boolean tryAcceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { Status tryAcceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
PolicySelection policySelection = PolicySelection policySelection =
(PolicySelection) resolvedAddresses.getLoadBalancingPolicyConfig(); (PolicySelection) resolvedAddresses.getLoadBalancingPolicyConfig();
@ -116,7 +116,7 @@ public final class AutoConfiguredLoadBalancerFactory {
delegate.shutdown(); delegate.shutdown();
delegateProvider = null; delegateProvider = null;
delegate = new NoopLoadBalancer(); delegate = new NoopLoadBalancer();
return true; return Status.OK;
} }
policySelection = policySelection =
new PolicySelection(defaultProvider, /* config= */ null); new PolicySelection(defaultProvider, /* config= */ null);

6
core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
View File

@ -1805,7 +1805,7 @@ final class ManagedChannelImpl extends ManagedChannel implements
// GrpcUtil.getTransportFromPickResult(). // GrpcUtil.getTransportFromPickResult().
onError(configOrError.getError()); onError(configOrError.getError());
if (resolutionResultListener != null) { if (resolutionResultListener != null) {
resolutionResultListener.resolutionAttempted(false); resolutionResultListener.resolutionAttempted(configOrError.getError());
} }
return; return;
} else { } else {
@ -1851,7 +1851,7 @@ final class ManagedChannelImpl extends ManagedChannel implements
} }
Attributes attributes = attrBuilder.build(); Attributes attributes = attrBuilder.build();
boolean lastAddressesAccepted = helper.lb.tryAcceptResolvedAddresses( Status addressAcceptanceStatus = helper.lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setAttributes(attributes) .setAttributes(attributes)
@ -1859,7 +1859,7 @@ final class ManagedChannelImpl extends ManagedChannel implements
.build()); .build());
// If a listener is provided, let it know if the addresses were accepted. // If a listener is provided, let it know if the addresses were accepted.
if (resolutionResultListener != null) { if (resolutionResultListener != null) {
resolutionResultListener.resolutionAttempted(lastAddressesAccepted); resolutionResultListener.resolutionAttempted(addressAcceptanceStatus);
} }
} }
} }

23
core/src/main/java/io/grpc/internal/PickFirstLeafLoadBalancer.java
View File

@ -62,20 +62,23 @@ final class PickFirstLeafLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses(); List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
if (servers.isEmpty()) { if (servers.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses() "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes())); + ", attrs=" + resolvedAddresses.getAttributes());
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
for (EquivalentAddressGroup eag : servers) { for (EquivalentAddressGroup eag : servers) {
if (eag == null) { if (eag == null) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned address list with null endpoint. addrs=" "NameResolver returned address list with null endpoint. addrs="
+ resolvedAddresses.getAddresses() + ", attrs=" + resolvedAddresses.getAttributes())); + resolvedAddresses.getAddresses() + ", attrs="
return false; + resolvedAddresses.getAttributes());
handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
} }
// We can optionally be configured to shuffle the address list. This can help better distribute // We can optionally be configured to shuffle the address list. This can help better distribute
@ -102,7 +105,7 @@ final class PickFirstLeafLoadBalancer extends LoadBalancer {
SocketAddress previousAddress = addressIndex.getCurrentAddress(); SocketAddress previousAddress = addressIndex.getCurrentAddress();
addressIndex.updateGroups(newImmutableAddressGroups); addressIndex.updateGroups(newImmutableAddressGroups);
if (addressIndex.seekTo(previousAddress)) { if (addressIndex.seekTo(previousAddress)) {
return true; return Status.OK;
} }
addressIndex.reset(); addressIndex.reset();
} else { } else {
@ -144,7 +147,7 @@ final class PickFirstLeafLoadBalancer extends LoadBalancer {
requestConnection(); requestConnection();
} }
return true; return Status.OK;
} }
@Override @Override

13
core/src/main/java/io/grpc/internal/PickFirstLoadBalancer.java
View File

@ -50,13 +50,14 @@ final class PickFirstLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses(); List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
if (servers.isEmpty()) { if (servers.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses() "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes())); + ", attrs=" + resolvedAddresses.getAttributes());
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
// We can optionally be configured to shuffle the address list. This can help better distribute // We can optionally be configured to shuffle the address list. This can help better distribute
@ -92,7 +93,7 @@ final class PickFirstLoadBalancer extends LoadBalancer {
subchannel.updateAddresses(servers); subchannel.updateAddresses(servers);
} }
return true; return Status.OK;
} }
@Override @Override

4
core/src/main/java/io/grpc/internal/RetryingNameResolver.java
View File

@ -114,8 +114,8 @@ final class RetryingNameResolver extends ForwardingNameResolver {
* the Listener2.onResult() API can be changed to return a boolean for this purpose. * the Listener2.onResult() API can be changed to return a boolean for this purpose.
*/ */
class ResolutionResultListener { class ResolutionResultListener {
public void resolutionAttempted(boolean successful) { public void resolutionAttempted(Status successStatus) {
if (successful) { if (successStatus.isOk()) {
retryScheduler.reset(); retryScheduler.reset();
} else { } else {
retryScheduler.schedule(new DelayedNameResolverRefresh()); retryScheduler.schedule(new DelayedNameResolverRefresh());

67
core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java
View File

@ -97,8 +97,10 @@ public class AutoConfiguredLoadBalancerFactoryTest {
@Before @Before
public void setUp() { public void setUp() {
when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(true); when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
when(testLbBalancer2.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(true); Status.OK);
when(testLbBalancer2.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
Status.OK);
defaultRegistry.register(testLbBalancerProvider); defaultRegistry.register(testLbBalancerProvider);
defaultRegistry.register(testLbBalancerProvider2); defaultRegistry.register(testLbBalancerProvider2);
} }
@ -183,14 +185,14 @@ public class AutoConfiguredLoadBalancerFactoryTest {
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
LoadBalancer oldDelegate = lb.getDelegate(); LoadBalancer oldDelegate = lb.getDelegate();
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setAttributes(Attributes.EMPTY) .setAttributes(Attributes.EMPTY)
.setLoadBalancingPolicyConfig(null) .setLoadBalancingPolicyConfig(null)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate); assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate);
} }
@ -225,13 +227,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
}; };
lb.setDelegate(testlb); lb.setDelegate(testlb);
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegateProvider().getClass().getName()).isEqualTo( assertThat(lb.getDelegateProvider().getClass().getName()).isEqualTo(
"io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider"); "io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
assertTrue(shutdown.get()); assertTrue(shutdown.get());
@ -250,14 +252,14 @@ public class AutoConfiguredLoadBalancerFactoryTest {
Helper helper = new TestHelper(); Helper helper = new TestHelper();
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
verify(testLbBalancerProvider).newLoadBalancer(same(helper)); verify(testLbBalancerProvider).newLoadBalancer(same(helper));
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
@ -272,7 +274,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"low\" } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"low\" } } ] }");
lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig); lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
addressesAccepted = lb.tryAcceptResolvedAddresses( addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
@ -281,7 +283,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
resultCaptor = resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture()); verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder(); assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
verify(testLbBalancerProvider, times(2)) verify(testLbBalancerProvider, times(2))
.parseLoadBalancingPolicyConfig(lbConfigCaptor.capture()); .parseLoadBalancingPolicyConfig(lbConfigCaptor.capture());
@ -303,14 +305,14 @@ public class AutoConfiguredLoadBalancerFactoryTest {
List<EquivalentAddressGroup> servers = List<EquivalentAddressGroup> servers =
Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(8080){})); Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(8080){}));
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
verify(testLbBalancerProvider).newLoadBalancer(same(helper)); verify(testLbBalancerProvider).newLoadBalancer(same(helper));
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
@ -319,13 +321,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
servers = servers =
Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(9090){})); Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(9090){}));
addressesAccepted = lb.tryAcceptResolvedAddresses( addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture()); verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder(); assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
} }
@ -335,7 +337,8 @@ public class AutoConfiguredLoadBalancerFactoryTest {
throws Exception { throws Exception {
// The test LB will NOT accept the addresses we give them. // The test LB will NOT accept the addresses we give them.
when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(false); when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
Status.UNAVAILABLE);
Helper helper = new TestHelper(); Helper helper = new TestHelper();
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
@ -343,13 +346,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
Map<String, ?> serviceConfig = Map<String, ?> serviceConfig =
parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
ConfigOrError lbConfig = lbf.parseLoadBalancerPolicy(serviceConfig); ConfigOrError lbConfig = lbf.parseLoadBalancerPolicy(serviceConfig);
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(Collections.<EquivalentAddressGroup>emptyList()) .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
.setLoadBalancingPolicyConfig(lbConfig.getConfig()) .setLoadBalancingPolicyConfig(lbConfig.getConfig())
.build()); .build());
assertThat(addressesAccepted).isFalse(); assertThat(addressesAcceptanceStatus.isOk()).isFalse();
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
} }
@ -363,13 +366,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
parseConfig("{\"loadBalancingConfig\": [ {\"test_lb2\": { \"setting1\": \"high\" } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"test_lb2\": { \"setting1\": \"high\" } } ] }");
ConfigOrError lbConfigs = ConfigOrError lbConfigs =
lbf.parseLoadBalancerPolicy(rawServiceConfig); lbf.parseLoadBalancerPolicy(rawServiceConfig);
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(Collections.<EquivalentAddressGroup>emptyList()) .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer2); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer2);
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
@ -398,12 +401,12 @@ public class AutoConfiguredLoadBalancerFactoryTest {
} }
}; };
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegate().getClass().getName()) assertThat(lb.getDelegate().getClass().getName())
.isEqualTo("io.grpc.util.RoundRobinLoadBalancer"); .isEqualTo("io.grpc.util.RoundRobinLoadBalancer");
} }
@ -420,12 +423,12 @@ public class AutoConfiguredLoadBalancerFactoryTest {
} }
}; };
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(null) .setLoadBalancingPolicyConfig(null)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegate()).isInstanceOf(PickFirstLoadBalancer.class); assertThat(lb.getDelegate()).isInstanceOf(PickFirstLoadBalancer.class);
} }
@ -435,12 +438,12 @@ public class AutoConfiguredLoadBalancerFactoryTest {
.newLoadBalancer(new TestHelper()); .newLoadBalancer(new TestHelper());
List<EquivalentAddressGroup> servers = List<EquivalentAddressGroup> servers =
Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){})); Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(null) .setLoadBalancingPolicyConfig(null)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
} }
@ -457,13 +460,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
AutoConfiguredLoadBalancer lb = AutoConfiguredLoadBalancer lb =
new AutoConfiguredLoadBalancerFactory(GrpcUtil.DEFAULT_LB_POLICY).newLoadBalancer(helper); new AutoConfiguredLoadBalancerFactory(GrpcUtil.DEFAULT_LB_POLICY).newLoadBalancer(helper);
boolean addressesAccepted = lb.tryAcceptResolvedAddresses( Status addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setAttributes(Attributes.EMPTY) .setAttributes(Attributes.EMPTY)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verifyNoMoreInteractions(channelLogger); verifyNoMoreInteractions(channelLogger);
ConfigOrError testLbParsedConfig = ConfigOrError.fromConfig("foo"); ConfigOrError testLbParsedConfig = ConfigOrError.fromConfig("foo");
@ -471,13 +474,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
Map<String, ?> serviceConfig = Map<String, ?> serviceConfig =
parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }");
ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig); ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig);
addressesAccepted = lb.tryAcceptResolvedAddresses( addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(channelLogger).log( verify(channelLogger).log(
eq(ChannelLogLevel.INFO), eq(ChannelLogLevel.INFO),
eq("Load balancer changed from {0} to {1}"), eq("Load balancer changed from {0} to {1}"),
@ -494,12 +497,12 @@ public class AutoConfiguredLoadBalancerFactoryTest {
nextParsedConfigOrError.set(testLbParsedConfig); nextParsedConfigOrError.set(testLbParsedConfig);
serviceConfig = parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }"); serviceConfig = parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }");
lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig); lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig);
addressesAccepted = lb.tryAcceptResolvedAddresses( addressesAcceptanceStatus = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(channelLogger).log( verify(channelLogger).log(
eq(ChannelLogLevel.DEBUG), eq(ChannelLogLevel.DEBUG),
eq("Load-balancing config: {0}"), eq("Load-balancing config: {0}"),
@ -647,7 +650,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return delegate().acceptResolvedAddresses(resolvedAddresses); return delegate().acceptResolvedAddresses(resolvedAddresses);
} }

4
core/src/test/java/io/grpc/internal/DnsNameResolverTest.java
View File

@ -230,7 +230,7 @@ public class DnsNameResolverTest {
ResolutionResult result = invocation.getArgument(0); ResolutionResult result = invocation.getArgument(0);
syncContext.execute( syncContext.execute(
() -> result.getAttributes().get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY) () -> result.getAttributes().get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY)
.resolutionAttempted(true)); .resolutionAttempted(Status.OK));
return null; return null;
}).when(mockListener).onResult(isA(ResolutionResult.class)); }).when(mockListener).onResult(isA(ResolutionResult.class));
} }
@ -591,7 +591,7 @@ public class DnsNameResolverTest {
doAnswer(invocation -> { doAnswer(invocation -> {
ResolutionResult result = invocation.getArgument(0); ResolutionResult result = invocation.getArgument(0);
result.getAttributes().get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY) result.getAttributes().get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY)
.resolutionAttempted(false); .resolutionAttempted(Status.UNAVAILABLE);
return null; return null;
}).when(mockListener).onResult(isA(ResolutionResult.class)); }).when(mockListener).onResult(isA(ResolutionResult.class));

3
core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
View File

@ -154,7 +154,8 @@ public class ManagedChannelImplIdlenessTest {
@Before @Before
@SuppressWarnings("deprecation") // For NameResolver.Listener @SuppressWarnings("deprecation") // For NameResolver.Listener
public void setUp() { public void setUp() {
when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(true); when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
Status.OK);
LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider); LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
when(mockNameResolver.getServiceAuthority()).thenReturn(AUTHORITY); when(mockNameResolver.getServiceAuthority()).thenReturn(AUTHORITY);
when(mockNameResolverFactory when(mockNameResolverFactory

3
core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
View File

@ -316,7 +316,8 @@ public class ManagedChannelImplTest {
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(true); when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
Status.OK);
LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider); LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
expectedUri = new URI(TARGET); expectedUri = new URI(TARGET);
transports = TestUtils.captureTransports(mockTransportFactory); transports = TestUtils.captureTransports(mockTransportFactory);

6
core/src/test/java/io/grpc/internal/PickFirstLeafLoadBalancerTest.java
View File

@ -562,8 +562,8 @@ public class PickFirstLeafLoadBalancerTest {
loadBalancer.acceptResolvedAddresses( loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build()); ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
assertFalse(loadBalancer.acceptResolvedAddresses( assertFalse(loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder().setAddresses(Arrays.<EquivalentAddressGroup>asList())
.setAddresses(Arrays.<EquivalentAddressGroup>asList()).setAttributes(affinity).build())); .setAttributes(affinity).build()).isOk());
assertEquals(TRANSIENT_FAILURE, loadBalancer.getCurrentState()); assertEquals(TRANSIENT_FAILURE, loadBalancer.getCurrentState());
} }
@ -573,7 +573,7 @@ public class PickFirstLeafLoadBalancerTest {
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build()); ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
List<EquivalentAddressGroup> eags = Arrays.asList((EquivalentAddressGroup) null); List<EquivalentAddressGroup> eags = Arrays.asList((EquivalentAddressGroup) null);
assertFalse(loadBalancer.acceptResolvedAddresses( assertFalse(loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(eags).setAttributes(affinity).build())); ResolvedAddresses.newBuilder().setAddresses(eags).setAttributes(affinity).build()).isOk());
assertEquals(TRANSIENT_FAILURE, loadBalancer.getCurrentState()); assertEquals(TRANSIENT_FAILURE, loadBalancer.getCurrentState());
} }

4
core/src/test/java/io/grpc/internal/RetryingNameResolverTest.java
View File

@ -90,7 +90,7 @@ public class RetryingNameResolverTest {
.get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY); .get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY);
assertThat(resolutionResultListener).isNotNull(); assertThat(resolutionResultListener).isNotNull();
resolutionResultListener.resolutionAttempted(true); resolutionResultListener.resolutionAttempted(Status.OK);
verify(mockRetryScheduler).reset(); verify(mockRetryScheduler).reset();
} }
@ -108,7 +108,7 @@ public class RetryingNameResolverTest {
.get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY); .get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY);
assertThat(resolutionResultListener).isNotNull(); assertThat(resolutionResultListener).isNotNull();
resolutionResultListener.resolutionAttempted(false); resolutionResultListener.resolutionAttempted(Status.UNAVAILABLE);
verify(mockRetryScheduler).schedule(isA(Runnable.class)); verify(mockRetryScheduler).schedule(isA(Runnable.class));
} }

14
core/src/test/java/io/grpc/internal/ServiceConfigErrorHandlingTest.java
View File

@ -192,7 +192,7 @@ public class ServiceConfigErrorHandlingTest {
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
mockLoadBalancer.setAcceptAddresses(true); mockLoadBalancer.setAddressAcceptanceStatus(Status.OK);
LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider); LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
expectedUri = new URI(TARGET); expectedUri = new URI(TARGET);
when(mockTransportFactory.getScheduledExecutorService()) when(mockTransportFactory.getScheduledExecutorService())
@ -280,7 +280,7 @@ public class ServiceConfigErrorHandlingTest {
nameResolverFactory.servers.clear(); nameResolverFactory.servers.clear();
// 2nd resolution // 2nd resolution
mockLoadBalancer.setAcceptAddresses(false); mockLoadBalancer.setAddressAcceptanceStatus(Status.UNAVAILABLE);
nameResolverFactory.allResolved(); nameResolverFactory.allResolved();
// 2nd service config without addresses // 2nd service config without addresses
@ -649,7 +649,7 @@ public class ServiceConfigErrorHandlingTest {
private static class FakeLoadBalancer extends LoadBalancer { private static class FakeLoadBalancer extends LoadBalancer {
private boolean acceptAddresses = true; private Status addressAcceptanceStatus = Status.OK;
@Nullable @Nullable
private Helper helper; private Helper helper;
@ -659,12 +659,12 @@ public class ServiceConfigErrorHandlingTest {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return acceptAddresses; return addressAcceptanceStatus;
} }
public void setAcceptAddresses(boolean acceptAddresses) { public void setAddressAcceptanceStatus(Status addressAcceptanceStatus) {
this.acceptAddresses = acceptAddresses; this.addressAcceptanceStatus = addressAcceptanceStatus;
} }
@Override @Override

11
examples/src/main/java/io/grpc/examples/customloadbalance/ShufflingPickFirstLoadBalancer.java
View File

@ -63,13 +63,14 @@ class ShufflingPickFirstLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
List<EquivalentAddressGroup> servers = new ArrayList<>(resolvedAddresses.getAddresses()); List<EquivalentAddressGroup> servers = new ArrayList<>(resolvedAddresses.getAddresses());
if (servers.isEmpty()) { if (servers.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses() "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes())); + ", attrs=" + resolvedAddresses.getAttributes());
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
Config config Config config
@ -97,7 +98,7 @@ class ShufflingPickFirstLoadBalancer extends LoadBalancer {
subchannel.updateAddresses(servers); subchannel.updateAddresses(servers);
} }
return true; return Status.OK;
} }
@Override @Override

11
grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
View File

@ -76,16 +76,17 @@ class GrpclbLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
Attributes attributes = resolvedAddresses.getAttributes(); Attributes attributes = resolvedAddresses.getAttributes();
List<EquivalentAddressGroup> newLbAddresses = attributes.get(GrpclbConstants.ATTR_LB_ADDRS); List<EquivalentAddressGroup> newLbAddresses = attributes.get(GrpclbConstants.ATTR_LB_ADDRS);
if (newLbAddresses == null) { if (newLbAddresses == null) {
newLbAddresses = Collections.emptyList(); newLbAddresses = Collections.emptyList();
} }
if (newLbAddresses.isEmpty() && resolvedAddresses.getAddresses().isEmpty()) { if (newLbAddresses.isEmpty() && resolvedAddresses.getAddresses().isEmpty()) {
handleNameResolutionError( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
Status.UNAVAILABLE.withDescription("No backend or balancer addresses found")); "No backend or balancer addresses found");
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
List<EquivalentAddressGroup> overrideAuthorityLbAddresses = List<EquivalentAddressGroup> overrideAuthorityLbAddresses =
new ArrayList<>(newLbAddresses.size()); new ArrayList<>(newLbAddresses.size());
@ -115,7 +116,7 @@ class GrpclbLoadBalancer extends LoadBalancer {
grpclbState.handleAddresses(Collections.unmodifiableList(overrideAuthorityLbAddresses), grpclbState.handleAddresses(Collections.unmodifiableList(overrideAuthorityLbAddresses),
newBackendServers); newBackendServers);
return true; return Status.OK;
} }
@Override @Override

2
rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
View File

@ -303,7 +303,7 @@ final class LbPolicyConfiguration {
@Override @Override
public void run() { public void run() {
if (!lb.acceptResolvedAddresses( if (!lb.acceptResolvedAddresses(
childLbResolvedAddressFactory.create(lbConfig.getConfig()))) { childLbResolvedAddressFactory.create(lbConfig.getConfig())).isOk()) {
helper.refreshNameResolution(); helper.refreshNameResolution();
} }
lb.requestConnection(); lb.requestConnection();

4
rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
View File

@ -49,7 +49,7 @@ final class RlsLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(ChannelLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(ChannelLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
LbPolicyConfiguration lbPolicyConfiguration = LbPolicyConfiguration lbPolicyConfiguration =
(LbPolicyConfiguration) resolvedAddresses.getLoadBalancingPolicyConfig(); (LbPolicyConfiguration) resolvedAddresses.getLoadBalancingPolicyConfig();
@ -78,7 +78,7 @@ final class RlsLoadBalancer extends LoadBalancer {
// not required. // not required.
this.lbPolicyConfiguration = lbPolicyConfiguration; this.lbPolicyConfiguration = lbPolicyConfiguration;
} }
return true; return Status.OK;
} }
@Override @Override

4
rls/src/test/java/io/grpc/rls/CachingRlsLbClientTest.java
View File

@ -703,7 +703,7 @@ public class CachingRlsLbClientTest {
LoadBalancer loadBalancer = new LoadBalancer() { LoadBalancer loadBalancer = new LoadBalancer() {
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
Map<?, ?> config = (Map<?, ?>) resolvedAddresses.getLoadBalancingPolicyConfig(); Map<?, ?> config = (Map<?, ?>) resolvedAddresses.getLoadBalancingPolicyConfig();
if (DEFAULT_TARGET.equals(config.get("target"))) { if (DEFAULT_TARGET.equals(config.get("target"))) {
helper.updateBalancingState( helper.updateBalancingState(
@ -727,7 +727,7 @@ public class CachingRlsLbClientTest {
}); });
} }
return true; return Status.OK;
} }
@Override @Override

4
rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java
View File

@ -36,6 +36,7 @@ import io.grpc.LoadBalancer.SubchannelPicker;
import io.grpc.LoadBalancerProvider; import io.grpc.LoadBalancerProvider;
import io.grpc.LoadBalancerRegistry; import io.grpc.LoadBalancerRegistry;
import io.grpc.NameResolver.ConfigOrError; import io.grpc.NameResolver.ConfigOrError;
import io.grpc.Status;
import io.grpc.SynchronizationContext; import io.grpc.SynchronizationContext;
import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider; import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
import io.grpc.rls.LbPolicyConfiguration.ChildLbStatusListener; import io.grpc.rls.LbPolicyConfiguration.ChildLbStatusListener;
@ -95,6 +96,7 @@ public class LbPolicyConfigurationTest {
doReturn(lb).when(lbProvider).newLoadBalancer(any(Helper.class)); doReturn(lb).when(lbProvider).newLoadBalancer(any(Helper.class));
doReturn(ConfigOrError.fromConfig(new Object())) doReturn(ConfigOrError.fromConfig(new Object()))
.when(lbProvider).parseLoadBalancingPolicyConfig(ArgumentMatchers.<Map<String, ?>>any()); .when(lbProvider).parseLoadBalancingPolicyConfig(ArgumentMatchers.<Map<String, ?>>any());
doReturn(Status.OK).when(lb).acceptResolvedAddresses(any(ResolvedAddresses.class));
} }
@Test @Test
@ -123,7 +125,7 @@ public class LbPolicyConfigurationTest {
@Test @Test
public void childPolicyWrapper_addressesRejected() { public void childPolicyWrapper_addressesRejected() {
when(lb.acceptResolvedAddresses(any(ResolvedAddresses.class))).thenReturn(false); when(lb.acceptResolvedAddresses(any(ResolvedAddresses.class))).thenReturn(Status.UNAVAILABLE);
factory.createOrGet("target"); factory.createOrGet("target");
verify(helper).refreshNameResolution(); verify(helper).refreshNameResolution();
} }

13
util/src/main/java/io/grpc/util/MultiChildLoadBalancer.java
View File

@ -143,7 +143,7 @@ public abstract class MultiChildLoadBalancer extends LoadBalancer {
* Override to completely replace the default logic or to do additional activities. * Override to completely replace the default logic or to do additional activities.
*/ */
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
try { try {
resolvingAddresses = true; resolvingAddresses = true;
return acceptResolvedAddressesInternal(resolvedAddresses); return acceptResolvedAddressesInternal(resolvedAddresses);
@ -183,14 +183,15 @@ public abstract class MultiChildLoadBalancer extends LoadBalancer {
.build(); .build();
} }
private boolean acceptResolvedAddressesInternal(ResolvedAddresses resolvedAddresses) { private Status acceptResolvedAddressesInternal(ResolvedAddresses resolvedAddresses) {
logger.log(Level.FINE, "Received resolution result: {0}", resolvedAddresses); logger.log(Level.FINE, "Received resolution result: {0}", resolvedAddresses);
Map<Object, ChildLbState> newChildren = createChildLbMap(resolvedAddresses); Map<Object, ChildLbState> newChildren = createChildLbMap(resolvedAddresses);
if (newChildren.isEmpty()) { if (newChildren.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. " + resolvedAddresses)); "NameResolver returned no usable address. " + resolvedAddresses);
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
// Do adds and updates // Do adds and updates
@ -223,7 +224,7 @@ public abstract class MultiChildLoadBalancer extends LoadBalancer {
// Must update channel picker before return so that new RPCs will not be routed to deleted // Must update channel picker before return so that new RPCs will not be routed to deleted
// clusters and resolver can remove them in service config. // clusters and resolver can remove them in service config.
updateOverallBalancingState(); updateOverallBalancingState();
return true; return Status.OK;
} }
@Override @Override

4
util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancer.java
View File

@ -95,7 +95,7 @@ public final class OutlierDetectionLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(ChannelLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(ChannelLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
OutlierDetectionLoadBalancerConfig config OutlierDetectionLoadBalancerConfig config
= (OutlierDetectionLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig(); = (OutlierDetectionLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
@ -149,7 +149,7 @@ public final class OutlierDetectionLoadBalancer extends LoadBalancer {
switchLb.handleResolvedAddresses( switchLb.handleResolvedAddresses(
resolvedAddresses.toBuilder().setLoadBalancingPolicyConfig(config.childPolicy.getConfig()) resolvedAddresses.toBuilder().setLoadBalancingPolicyConfig(config.childPolicy.getConfig())
.build()); .build());
return true; return Status.OK;
} }
@Override @Override

4
util/src/test/java/io/grpc/util/OutlierDetectionLoadBalancerTest.java
View File

@ -1207,7 +1207,7 @@ public class OutlierDetectionLoadBalancerTest {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
subchannelList = new ArrayList<>(); subchannelList = new ArrayList<>();
for (EquivalentAddressGroup eag: resolvedAddresses.getAddresses()) { for (EquivalentAddressGroup eag: resolvedAddresses.getAddresses()) {
Subchannel subchannel = helper.createSubchannel(CreateSubchannelArgs.newBuilder() Subchannel subchannel = helper.createSubchannel(CreateSubchannelArgs.newBuilder()
@ -1216,7 +1216,7 @@ public class OutlierDetectionLoadBalancerTest {
subchannel.start(mock(SubchannelStateListener.class)); subchannel.start(mock(SubchannelStateListener.class));
deliverSubchannelState(READY); deliverSubchannelState(READY);
} }
return true; return Status.OK;
} }
@Override @Override

40
util/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
View File

@ -114,7 +114,7 @@ public class RoundRobinLoadBalancerTest {
loadBalancer = new RoundRobinLoadBalancer(mockHelper); loadBalancer = new RoundRobinLoadBalancer(mockHelper);
} }
private boolean acceptAddresses(List<EquivalentAddressGroup> eagList, Attributes attrs) { private Status acceptAddresses(List<EquivalentAddressGroup> eagList, Attributes attrs) {
return loadBalancer.acceptResolvedAddresses( return loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(eagList).setAttributes(attrs).build()); ResolvedAddresses.newBuilder().setAddresses(eagList).setAttributes(attrs).build());
} }
@ -126,8 +126,8 @@ public class RoundRobinLoadBalancerTest {
@Test @Test
public void pickAfterResolved() throws Exception { public void pickAfterResolved() throws Exception {
boolean addressesAccepted = acceptAddresses(servers, affinity); Status addressesAcceptanceStatus = acceptAddresses(servers, affinity);
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
final Subchannel readySubchannel = subchannels.values().iterator().next(); final Subchannel readySubchannel = subchannels.values().iterator().next();
deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY)); deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
@ -181,8 +181,8 @@ public class RoundRobinLoadBalancerTest {
InOrder inOrder = inOrder(mockHelper); InOrder inOrder = inOrder(mockHelper);
boolean addressesAccepted = acceptAddresses(currentServers, affinity); Status addressesAcceptanceStatus = acceptAddresses(currentServers, affinity);
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture()); inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
@ -205,9 +205,9 @@ public class RoundRobinLoadBalancerTest {
// This time with Attributes // This time with Attributes
List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag); List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag);
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(latestServers).setAttributes(affinity).build()); ResolvedAddresses.newBuilder().setAddresses(latestServers).setAttributes(affinity).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(newSubchannel, times(1)).requestConnection(); verify(newSubchannel, times(1)).requestConnection();
verify(oldSubchannel, times(1)).updateAddresses(Arrays.asList(oldEag2)); verify(oldSubchannel, times(1)).updateAddresses(Arrays.asList(oldEag2));
@ -233,8 +233,8 @@ public class RoundRobinLoadBalancerTest {
@Test @Test
public void pickAfterStateChange() throws Exception { public void pickAfterStateChange() throws Exception {
InOrder inOrder = inOrder(mockHelper); InOrder inOrder = inOrder(mockHelper);
boolean addressesAccepted = acceptAddresses(servers, Attributes.EMPTY); Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
// TODO figure out if this method testing the right things // TODO figure out if this method testing the right things
@ -270,8 +270,8 @@ public class RoundRobinLoadBalancerTest {
@Test @Test
public void ignoreShutdownSubchannelStateChange() { public void ignoreShutdownSubchannelStateChange() {
InOrder inOrder = inOrder(mockHelper); InOrder inOrder = inOrder(mockHelper);
boolean addressesAccepted = acceptAddresses(servers, Attributes.EMPTY); Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class)); inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
loadBalancer.shutdown(); loadBalancer.shutdown();
@ -289,8 +289,8 @@ public class RoundRobinLoadBalancerTest {
@Test @Test
public void stayTransientFailureUntilReady() { public void stayTransientFailureUntilReady() {
InOrder inOrder = inOrder(mockHelper); InOrder inOrder = inOrder(mockHelper);
boolean addressesAccepted = acceptAddresses(servers, Attributes.EMPTY); Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class)); inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
@ -326,8 +326,8 @@ public class RoundRobinLoadBalancerTest {
@Test @Test
public void refreshNameResolutionWhenSubchannelConnectionBroken() { public void refreshNameResolutionWhenSubchannelConnectionBroken() {
InOrder inOrder = inOrder(mockHelper); InOrder inOrder = inOrder(mockHelper);
boolean addressesAccepted = acceptAddresses(servers, Attributes.EMPTY); Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class)); inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
@ -393,9 +393,9 @@ public class RoundRobinLoadBalancerTest {
@Test @Test
public void nameResolutionErrorWithActiveChannels() throws Exception { public void nameResolutionErrorWithActiveChannels() throws Exception {
boolean addressesAccepted = acceptAddresses(servers, affinity); Status addressesAcceptanceStatus = acceptAddresses(servers, affinity);
final Subchannel readySubchannel = subchannels.values().iterator().next(); final Subchannel readySubchannel = subchannels.values().iterator().next();
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY)); deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
loadBalancer.resolvingAddresses = true; loadBalancer.resolvingAddresses = true;
loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError")); loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
@ -420,8 +420,8 @@ public class RoundRobinLoadBalancerTest {
@Test @Test
public void subchannelStateIsolation() throws Exception { public void subchannelStateIsolation() throws Exception {
boolean addressesAccepted = acceptAddresses(servers, Attributes.EMPTY); Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
Iterator<Subchannel> subchannelIterator = subchannels.values().iterator(); Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
Subchannel sc1 = subchannelIterator.next(); Subchannel sc1 = subchannelIterator.next();
@ -505,7 +505,7 @@ public class RoundRobinLoadBalancerTest {
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(Collections.emptyList()) .setAddresses(Collections.emptyList())
.setAttributes(affinity) .setAttributes(affinity)
.build())).isFalse(); .build()).isOk()).isFalse();
} }
private List<Subchannel> getList(SubchannelPicker picker) { private List<Subchannel> getList(SubchannelPicker picker) {

6
xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java
View File

@ -82,9 +82,9 @@ final class CdsLoadBalancer2 extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
if (this.resolvedAddresses != null) { if (this.resolvedAddresses != null) {
return true; return Status.OK;
} }
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
this.resolvedAddresses = resolvedAddresses; this.resolvedAddresses = resolvedAddresses;
@ -94,7 +94,7 @@ final class CdsLoadBalancer2 extends LoadBalancer {
logger.log(XdsLogLevel.INFO, "Config: {0}", config); logger.log(XdsLogLevel.INFO, "Config: {0}", config);
cdsLbState = new CdsLbState(config.name); cdsLbState = new CdsLbState(config.name);
cdsLbState.start(); cdsLbState.start();
return true; return Status.OK;
} }
@Override @Override

4
xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java
View File

@ -101,7 +101,7 @@ final class ClusterImplLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
Attributes attributes = resolvedAddresses.getAttributes(); Attributes attributes = resolvedAddresses.getAttributes();
if (xdsClientPool == null) { if (xdsClientPool == null) {
@ -135,7 +135,7 @@ final class ClusterImplLoadBalancer extends LoadBalancer {
.setAttributes(attributes) .setAttributes(attributes)
.setLoadBalancingPolicyConfig(config.childPolicy.getConfig()) .setLoadBalancingPolicyConfig(config.childPolicy.getConfig())
.build()); .build());
return true; return Status.OK;
} }
@Override @Override

8
xds/src/main/java/io/grpc/xds/ClusterResolverLoadBalancer.java
View File

@ -112,7 +112,7 @@ final class ClusterResolverLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
if (xdsClientPool == null) { if (xdsClientPool == null) {
xdsClientPool = resolvedAddresses.getAttributes().get(InternalXdsAttributes.XDS_CLIENT_POOL); xdsClientPool = resolvedAddresses.getAttributes().get(InternalXdsAttributes.XDS_CLIENT_POOL);
@ -126,7 +126,7 @@ final class ClusterResolverLoadBalancer extends LoadBalancer {
this.config = config; this.config = config;
delegate.handleResolvedAddresses(resolvedAddresses); delegate.handleResolvedAddresses(resolvedAddresses);
} }
return true; return Status.OK;
} }
@Override @Override
@ -170,7 +170,7 @@ final class ClusterResolverLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
this.resolvedAddresses = resolvedAddresses; this.resolvedAddresses = resolvedAddresses;
ClusterResolverConfig config = ClusterResolverConfig config =
(ClusterResolverConfig) resolvedAddresses.getLoadBalancingPolicyConfig(); (ClusterResolverConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
@ -189,7 +189,7 @@ final class ClusterResolverLoadBalancer extends LoadBalancer {
clusterStates.put(instance.cluster, state); clusterStates.put(instance.cluster, state);
state.start(); state.start();
} }
return true; return Status.OK;
} }
@Override @Override

8
xds/src/main/java/io/grpc/xds/LeastRequestLoadBalancer.java
View File

@ -82,7 +82,7 @@ final class LeastRequestLoadBalancer extends MultiChildLoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
// Need to update choiceCount before calling super so that the updateBalancingState call has the // Need to update choiceCount before calling super so that the updateBalancingState call has the
// new value. However, if the update fails we need to revert it. // new value. However, if the update fails we need to revert it.
int oldChoiceCount = choiceCount; int oldChoiceCount = choiceCount;
@ -92,13 +92,13 @@ final class LeastRequestLoadBalancer extends MultiChildLoadBalancer {
choiceCount = config.choiceCount; choiceCount = config.choiceCount;
} }
boolean successfulUpdate = super.acceptResolvedAddresses(resolvedAddresses); Status addressAcceptanceStatus = super.acceptResolvedAddresses(resolvedAddresses);
if (!successfulUpdate) { if (!addressAcceptanceStatus.isOk()) {
choiceCount = oldChoiceCount; choiceCount = oldChoiceCount;
} }
return successfulUpdate; return addressAcceptanceStatus;
} }
@Override @Override

4
xds/src/main/java/io/grpc/xds/PriorityLoadBalancer.java
View File

@ -85,7 +85,7 @@ final class PriorityLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
this.resolvedAddresses = resolvedAddresses; this.resolvedAddresses = resolvedAddresses;
PriorityLbConfig config = (PriorityLbConfig) resolvedAddresses.getLoadBalancingPolicyConfig(); PriorityLbConfig config = (PriorityLbConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
@ -111,7 +111,7 @@ final class PriorityLoadBalancer extends LoadBalancer {
} }
handlingResolvedAddresses = false; handlingResolvedAddresses = false;
tryNextPriority(); tryNextPriority();
return true; return Status.OK;
} }
@Override @Override

50
xds/src/main/java/io/grpc/xds/RingHashLoadBalancer.java
View File

@ -86,11 +86,12 @@ final class RingHashLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
List<EquivalentAddressGroup> addrList = resolvedAddresses.getAddresses(); List<EquivalentAddressGroup> addrList = resolvedAddresses.getAddresses();
if (!validateAddrList(addrList)) { Status addressValidityStatus = validateAddrList(addrList);
return false; if (!addressValidityStatus.isOk()) {
return addressValidityStatus;
} }
Map<EquivalentAddressGroup, EquivalentAddressGroup> latestAddrs = stripAttrs(addrList); Map<EquivalentAddressGroup, EquivalentAddressGroup> latestAddrs = stripAttrs(addrList);
@ -167,21 +168,23 @@ final class RingHashLoadBalancer extends LoadBalancer {
shutdownSubchannel(subchann); shutdownSubchannel(subchann);
} }
return true; return Status.OK;
} }
private boolean validateAddrList(List<EquivalentAddressGroup> addrList) { private Status validateAddrList(List<EquivalentAddressGroup> addrList) {
if (addrList.isEmpty()) { if (addrList.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription("Ring hash lb error: EDS " Status unavailableStatus = Status.UNAVAILABLE.withDescription("Ring hash lb error: EDS "
+ "resolution was successful, but returned server addresses are empty.")); + "resolution was successful, but returned server addresses are empty.");
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
String dupAddrString = validateNoDuplicateAddresses(addrList); String dupAddrString = validateNoDuplicateAddresses(addrList);
if (dupAddrString != null) { if (dupAddrString != null) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription("Ring hash lb error: EDS " Status unavailableStatus = Status.UNAVAILABLE.withDescription("Ring hash lb error: EDS "
+ "resolution was successful, but there were duplicate addresses: " + dupAddrString)); + "resolution was successful, but there were duplicate addresses: " + dupAddrString);
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
long totalWeight = 0; long totalWeight = 0;
@ -193,29 +196,32 @@ final class RingHashLoadBalancer extends LoadBalancer {
} }
if (weight < 0) { if (weight < 0) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
String.format("Ring hash lb error: EDS resolution was successful, but returned a " String.format("Ring hash lb error: EDS resolution was successful, but returned a "
+ "negative weight for %s.", stripAttrs(eag)))); + "negative weight for %s.", stripAttrs(eag)));
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
if (weight > UnsignedInteger.MAX_VALUE.longValue()) { if (weight > UnsignedInteger.MAX_VALUE.longValue()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
String.format("Ring hash lb error: EDS resolution was successful, but returned a weight" String.format("Ring hash lb error: EDS resolution was successful, but returned a weight"
+ " too large to fit in an unsigned int for %s.", stripAttrs(eag)))); + " too large to fit in an unsigned int for %s.", stripAttrs(eag)));
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
totalWeight += weight; totalWeight += weight;
} }
if (totalWeight > UnsignedInteger.MAX_VALUE.longValue()) { if (totalWeight > UnsignedInteger.MAX_VALUE.longValue()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
String.format( String.format(
"Ring hash lb error: EDS resolution was successful, but returned a sum of weights too" "Ring hash lb error: EDS resolution was successful, but returned a sum of weights too"
+ " large to fit in an unsigned int (%d).", totalWeight))); + " large to fit in an unsigned int (%d).", totalWeight));
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
return true; return Status.OK;
} }
@Nullable @Nullable

13
xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancer.java
View File

@ -104,23 +104,24 @@ final class WeightedRoundRobinLoadBalancer extends RoundRobinLoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
if (resolvedAddresses.getLoadBalancingPolicyConfig() == null) { if (resolvedAddresses.getLoadBalancingPolicyConfig() == null) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no WeightedRoundRobinLoadBalancerConfig. addrs=" "NameResolver returned no WeightedRoundRobinLoadBalancerConfig. addrs="
+ resolvedAddresses.getAddresses() + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes())); + ", attrs=" + resolvedAddresses.getAttributes());
return false; handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} }
config = config =
(WeightedRoundRobinLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig(); (WeightedRoundRobinLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
boolean accepted = super.acceptResolvedAddresses(resolvedAddresses); Status addressAcceptanceStatus = super.acceptResolvedAddresses(resolvedAddresses);
if (weightUpdateTimer != null && weightUpdateTimer.isPending()) { if (weightUpdateTimer != null && weightUpdateTimer.isPending()) {
weightUpdateTimer.cancel(); weightUpdateTimer.cancel();
} }
updateWeightTask.run(); updateWeightTask.run();
afterAcceptAddresses(); afterAcceptAddresses();
return accepted; return addressAcceptanceStatus;
} }
@Override @Override

6
xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancer.java
View File

@ -59,7 +59,7 @@ final class WeightedTargetLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
try { try {
resolvingAddresses = true; resolvingAddresses = true;
return acceptResolvedAddressesInternal(resolvedAddresses); return acceptResolvedAddressesInternal(resolvedAddresses);
@ -68,7 +68,7 @@ final class WeightedTargetLoadBalancer extends LoadBalancer {
} }
} }
public boolean acceptResolvedAddressesInternal(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddressesInternal(ResolvedAddresses resolvedAddresses) {
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
Object lbConfig = resolvedAddresses.getLoadBalancingPolicyConfig(); Object lbConfig = resolvedAddresses.getLoadBalancingPolicyConfig();
checkNotNull(lbConfig, "missing weighted_target lb config"); checkNotNull(lbConfig, "missing weighted_target lb config");
@ -107,7 +107,7 @@ final class WeightedTargetLoadBalancer extends LoadBalancer {
childBalancers.keySet().retainAll(targets.keySet()); childBalancers.keySet().retainAll(targets.keySet());
childHelpers.keySet().retainAll(targets.keySet()); childHelpers.keySet().retainAll(targets.keySet());
updateOverallBalancingState(); updateOverallBalancingState();
return true; return Status.OK;
} }
@Override @Override

21
xds/src/main/java/io/grpc/xds/WrrLocalityLoadBalancer.java
View File

@ -62,7 +62,7 @@ final class WrrLocalityLoadBalancer extends LoadBalancer {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses); logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
// The configuration with the child policy is combined with the locality weights // The configuration with the child policy is combined with the locality weights
@ -78,15 +78,18 @@ final class WrrLocalityLoadBalancer extends LoadBalancer {
Integer localityWeight = eagAttrs.get(InternalXdsAttributes.ATTR_LOCALITY_WEIGHT); Integer localityWeight = eagAttrs.get(InternalXdsAttributes.ATTR_LOCALITY_WEIGHT);
if (locality == null) { if (locality == null) {
helper.updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
Status.UNAVAILABLE.withDescription("wrr_locality error: no locality provided")))); "wrr_locality error: no locality provided");
return false; helper.updateBalancingState(TRANSIENT_FAILURE,
new FixedResultPicker(PickResult.withError(unavailableStatus)));
return unavailableStatus;
} }
if (localityWeight == null) { if (localityWeight == null) {
helper.updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError( Status unavailableStatus = Status.UNAVAILABLE.withDescription(
Status.UNAVAILABLE.withDescription( "wrr_locality error: no weight provided for locality " + locality);
"wrr_locality error: no weight provided for locality " + locality)))); helper.updateBalancingState(TRANSIENT_FAILURE,
return false; new FixedResultPicker(PickResult.withError(unavailableStatus)));
return unavailableStatus;
} }
if (!localityWeights.containsKey(locality)) { if (!localityWeights.containsKey(locality)) {
@ -113,7 +116,7 @@ final class WrrLocalityLoadBalancer extends LoadBalancer {
.setLoadBalancingPolicyConfig(new WeightedTargetConfig(weightedPolicySelections)) .setLoadBalancingPolicyConfig(new WeightedTargetConfig(weightedPolicySelections))
.build()); .build());
return true; return Status.OK;
} }
@Override @Override

4
xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java
View File

@ -741,11 +741,11 @@ public class ClusterImplLoadBalancerTest {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
addresses = resolvedAddresses.getAddresses(); addresses = resolvedAddresses.getAddresses();
config = resolvedAddresses.getLoadBalancingPolicyConfig(); config = resolvedAddresses.getLoadBalancingPolicyConfig();
attributes = resolvedAddresses.getAttributes(); attributes = resolvedAddresses.getAttributes();
return true; return Status.OK;
} }
@Override @Override

4
xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java
View File

@ -361,14 +361,14 @@ public class ClusterManagerLoadBalancerTest {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
config = resolvedAddresses.getLoadBalancingPolicyConfig(); config = resolvedAddresses.getLoadBalancingPolicyConfig();
if (failing) { if (failing) {
helper.updateBalancingState( helper.updateBalancingState(
TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.INTERNAL))); TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.INTERNAL)));
} }
return true; return Status.OK;
} }
@Override @Override

4
xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java
View File

@ -1335,10 +1335,10 @@ public class ClusterResolverLoadBalancerTest {
} }
@Override @Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) { public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
addresses = resolvedAddresses.getAddresses(); addresses = resolvedAddresses.getAddresses();
config = resolvedAddresses.getLoadBalancingPolicyConfig(); config = resolvedAddresses.getLoadBalancingPolicyConfig();
return true; return Status.OK;
} }
@Override @Override

50
xds/src/test/java/io/grpc/xds/LeastRequestLoadBalancerTest.java
View File

@ -133,9 +133,9 @@ public class LeastRequestLoadBalancerTest {
@Test @Test
public void pickAfterResolved() throws Exception { public void pickAfterResolved() throws Exception {
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build()); ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
final Subchannel readySubchannel = subchannels.values().iterator().next(); final Subchannel readySubchannel = subchannels.values().iterator().next();
deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY)); deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
@ -178,10 +178,10 @@ public class LeastRequestLoadBalancerTest {
InOrder inOrder = inOrder(helper); InOrder inOrder = inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(currentServers).setAttributes(affinity) ResolvedAddresses.newBuilder().setAddresses(currentServers).setAttributes(affinity)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
Subchannel removedSubchannel = getSubchannel(removedEag); Subchannel removedSubchannel = getSubchannel(removedEag);
Subchannel oldSubchannel = getSubchannel(oldEag1); Subchannel oldSubchannel = getSubchannel(oldEag1);
SubchannelStateListener removedListener = SubchannelStateListener removedListener =
@ -205,9 +205,9 @@ public class LeastRequestLoadBalancerTest {
// This time with Attributes // This time with Attributes
List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag); List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag);
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(latestServers).setAttributes(affinity).build()); ResolvedAddresses.newBuilder().setAddresses(latestServers).setAttributes(affinity).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
Subchannel newSubchannel = getSubchannel(newEag); Subchannel newSubchannel = getSubchannel(newEag);
@ -257,10 +257,10 @@ public class LeastRequestLoadBalancerTest {
@Test @Test
public void pickAfterStateChange() throws Exception { public void pickAfterStateChange() throws Exception {
InOrder inOrder = inOrder(helper); InOrder inOrder = inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
ChildLbState childLbState = loadBalancer.getChildLbStates().iterator().next(); ChildLbState childLbState = loadBalancer.getChildLbStates().iterator().next();
Subchannel subchannel = getSubchannel(childLbState); Subchannel subchannel = getSubchannel(childLbState);
@ -297,10 +297,10 @@ public class LeastRequestLoadBalancerTest {
public void pickAfterConfigChange() { public void pickAfterConfigChange() {
final LeastRequestConfig oldConfig = new LeastRequestConfig(4); final LeastRequestConfig oldConfig = new LeastRequestConfig(4);
final LeastRequestConfig newConfig = new LeastRequestConfig(6); final LeastRequestConfig newConfig = new LeastRequestConfig(6);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
.setLoadBalancingPolicyConfig(oldConfig).build()); .setLoadBalancingPolicyConfig(oldConfig).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
final Subchannel readySubchannel = subchannels.values().iterator().next(); final Subchannel readySubchannel = subchannels.values().iterator().next();
deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY)); deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
@ -311,10 +311,10 @@ public class LeastRequestLoadBalancerTest {
pickerCaptor.getValue().pickSubchannel(mockArgs); pickerCaptor.getValue().pickSubchannel(mockArgs);
verify(mockRandom, times(oldConfig.choiceCount)).nextInt(1); verify(mockRandom, times(oldConfig.choiceCount)).nextInt(1);
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
.setLoadBalancingPolicyConfig(newConfig).build()); .setLoadBalancingPolicyConfig(newConfig).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)) verify(helper, times(3))
.updateBalancingState(any(ConnectivityState.class), pickerCaptor.capture()); .updateBalancingState(any(ConnectivityState.class), pickerCaptor.capture());
@ -327,10 +327,10 @@ public class LeastRequestLoadBalancerTest {
@Test @Test
public void ignoreShutdownSubchannelStateChange() { public void ignoreShutdownSubchannelStateChange() {
InOrder inOrder = inOrder(helper); InOrder inOrder = inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(helper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class)); inOrder.verify(helper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
loadBalancer.shutdown(); loadBalancer.shutdown();
@ -347,10 +347,10 @@ public class LeastRequestLoadBalancerTest {
@Test @Test
public void stayTransientFailureUntilReady() { public void stayTransientFailureUntilReady() {
InOrder inOrder = inOrder(helper); InOrder inOrder = inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(helper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class)); inOrder.verify(helper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
@ -416,10 +416,10 @@ public class LeastRequestLoadBalancerTest {
@Test @Test
public void refreshNameResolutionWhenSubchannelConnectionBroken() { public void refreshNameResolutionWhenSubchannelConnectionBroken() {
InOrder inOrder = inOrder(helper); InOrder inOrder = inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
inOrder.verify(helper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class)); inOrder.verify(helper).updateBalancingState(eq(CONNECTING), isA(EmptyPicker.class));
@ -447,11 +447,11 @@ public class LeastRequestLoadBalancerTest {
public void pickerLeastRequest() throws Exception { public void pickerLeastRequest() throws Exception {
int choiceCount = 2; int choiceCount = 2;
// This should add inFlight counters to all subchannels. // This should add inFlight counters to all subchannels.
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
.setLoadBalancingPolicyConfig(new LeastRequestConfig(choiceCount)) .setLoadBalancingPolicyConfig(new LeastRequestConfig(choiceCount))
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
assertEquals(3, loadBalancer.getChildLbStates().size()); assertEquals(3, loadBalancer.getChildLbStates().size());
@ -532,11 +532,11 @@ public class LeastRequestLoadBalancerTest {
@Test @Test
public void nameResolutionErrorWithActiveChannels() throws Exception { public void nameResolutionErrorWithActiveChannels() throws Exception {
int choiceCount = 8; int choiceCount = 8;
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setLoadBalancingPolicyConfig(new LeastRequestConfig(choiceCount)) .setLoadBalancingPolicyConfig(new LeastRequestConfig(choiceCount))
.setAddresses(servers).setAttributes(affinity).build()); .setAddresses(servers).setAttributes(affinity).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
final Subchannel readySubchannel = subchannels.values().iterator().next(); final Subchannel readySubchannel = subchannels.values().iterator().next();
deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY)); deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
@ -568,10 +568,10 @@ public class LeastRequestLoadBalancerTest {
@Test @Test
public void subchannelStateIsolation() throws Exception { public void subchannelStateIsolation() throws Exception {
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY) ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
.build()); .build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
Iterator<Subchannel> subchannelIterator = subchannels.values().iterator(); Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
Subchannel sc1 = subchannelIterator.next(); Subchannel sc1 = subchannelIterator.next();
Subchannel sc2 = subchannelIterator.next(); Subchannel sc2 = subchannelIterator.next();
@ -659,7 +659,7 @@ public class LeastRequestLoadBalancerTest {
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(Collections.<EquivalentAddressGroup>emptyList()) .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
.setAttributes(affinity) .setAttributes(affinity)
.build())) .build()).isOk())
.isFalse(); .isFalse();
} }

120
xds/src/test/java/io/grpc/xds/RingHashLoadBalancerTest.java
View File

@ -157,10 +157,10 @@ public class RingHashLoadBalancerTest {
public void subchannelLazyConnectUntilPicked() { public void subchannelLazyConnectUntilPicked() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1); // one server List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1); // one server
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
Subchannel subchannel = Iterables.getOnlyElement(subchannels.values()); Subchannel subchannel = Iterables.getOnlyElement(subchannels.values());
verify(subchannel, never()).requestConnection(); verify(subchannel, never()).requestConnection();
@ -189,10 +189,10 @@ public class RingHashLoadBalancerTest {
public void subchannelNotAutoReconnectAfterReenteringIdle() { public void subchannelNotAutoReconnectAfterReenteringIdle() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1); // one server List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1); // one server
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
Subchannel subchannel = Iterables.getOnlyElement(subchannels.values()); Subchannel subchannel = Iterables.getOnlyElement(subchannels.values());
InOrder inOrder = Mockito.inOrder(helper, subchannel); InOrder inOrder = Mockito.inOrder(helper, subchannel);
inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture()); inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
@ -220,10 +220,10 @@ public class RingHashLoadBalancerTest {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1);
InOrder inOrder = Mockito.inOrder(helper); InOrder inOrder = Mockito.inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(helper, times(2)).createSubchannel(any(CreateSubchannelArgs.class)); inOrder.verify(helper, times(2)).createSubchannel(any(CreateSubchannelArgs.class));
inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -282,10 +282,10 @@ public class RingHashLoadBalancerTest {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1, 1);
InOrder inOrder = Mockito.inOrder(helper); InOrder inOrder = Mockito.inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(helper, times(4)).createSubchannel(any(CreateSubchannelArgs.class)); inOrder.verify(helper, times(4)).createSubchannel(any(CreateSubchannelArgs.class));
inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -341,10 +341,10 @@ public class RingHashLoadBalancerTest {
public void subchannelStayInTransientFailureUntilBecomeReady() { public void subchannelStayInTransientFailureUntilBecomeReady() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
reset(helper); reset(helper);
@ -384,10 +384,10 @@ public class RingHashLoadBalancerTest {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
InOrder inOrder = Mockito.inOrder(helper); InOrder inOrder = Mockito.inOrder(helper);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -401,10 +401,10 @@ public class RingHashLoadBalancerTest {
verifyConnection(1); verifyConnection(1);
servers = createWeightedServerAddrs(1,1); servers = createWeightedServerAddrs(1,1);
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(helper) inOrder.verify(helper)
.updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class)); .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
verifyConnection(1); verifyConnection(1);
@ -430,10 +430,10 @@ public class RingHashLoadBalancerTest {
public void ignoreShutdownSubchannelStateChange() { public void ignoreShutdownSubchannelStateChange() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -451,10 +451,10 @@ public class RingHashLoadBalancerTest {
public void deterministicPickWithHostsPartiallyRemoved() { public void deterministicPickWithHostsPartiallyRemoved() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
InOrder inOrder = Mockito.inOrder(helper); InOrder inOrder = Mockito.inOrder(helper);
inOrder.verify(helper, times(5)).createSubchannel(any(CreateSubchannelArgs.class)); inOrder.verify(helper, times(5)).createSubchannel(any(CreateSubchannelArgs.class));
inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -480,10 +480,10 @@ public class RingHashLoadBalancerTest {
Attributes attr = addr.getAttributes().toBuilder().set(CUSTOM_KEY, "custom value").build(); Attributes attr = addr.getAttributes().toBuilder().set(CUSTOM_KEY, "custom value").build();
updatedServers.add(new EquivalentAddressGroup(addr.getAddresses(), attr)); updatedServers.add(new EquivalentAddressGroup(addr.getAddresses(), attr));
} }
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(updatedServers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(updatedServers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(subchannels.get(Collections.singletonList(servers.get(0)))) verify(subchannels.get(Collections.singletonList(servers.get(0))))
.updateAddresses(Collections.singletonList(updatedServers.get(0))); .updateAddresses(Collections.singletonList(updatedServers.get(0)));
verify(subchannels.get(Collections.singletonList(servers.get(1)))) verify(subchannels.get(Collections.singletonList(servers.get(1))))
@ -498,10 +498,10 @@ public class RingHashLoadBalancerTest {
public void deterministicPickWithNewHostsAdded() { public void deterministicPickWithNewHostsAdded() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1); // server0 and server1 List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1); // server0 and server1
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
InOrder inOrder = Mockito.inOrder(helper); InOrder inOrder = Mockito.inOrder(helper);
inOrder.verify(helper, times(2)).createSubchannel(any(CreateSubchannelArgs.class)); inOrder.verify(helper, times(2)).createSubchannel(any(CreateSubchannelArgs.class));
inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture()); inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
@ -523,10 +523,10 @@ public class RingHashLoadBalancerTest {
assertThat(subchannel.getAddresses()).isEqualTo(servers.get(1)); assertThat(subchannel.getAddresses()).isEqualTo(servers.get(1));
servers = createWeightedServerAddrs(1, 1, 1, 1, 1); // server2, server3, server4 added servers = createWeightedServerAddrs(1, 1, 1, 1, 1); // server2, server3, server4 added
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
inOrder.verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); inOrder.verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture()); inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
assertThat(pickerCaptor.getValue().pickSubchannel(args).getSubchannel()) assertThat(pickerCaptor.getValue().pickSubchannel(args).getSubchannel())
@ -539,10 +539,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); // initial IDLE verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); // initial IDLE
reset(helper); reset(helper);
@ -601,10 +601,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); // initial IDLE verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); // initial IDLE
reset(helper); reset(helper);
@ -668,10 +668,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -707,10 +707,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -739,10 +739,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -771,10 +771,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
// ring: // ring:
@ -807,10 +807,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
// ring: // ring:
@ -846,10 +846,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
// ring: // ring:
@ -889,10 +889,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
// ring: // ring:
@ -934,10 +934,10 @@ public class RingHashLoadBalancerTest {
// Map each server address to exactly one ring entry. // Map each server address to exactly one ring entry.
RingHashConfig config = new RingHashConfig(3, 3); RingHashConfig config = new RingHashConfig(3, 3);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -971,49 +971,49 @@ public class RingHashLoadBalancerTest {
RingHashConfig config = new RingHashConfig(10000, 100000); // large ring RingHashConfig config = new RingHashConfig(10000, 100000); // large ring
List<EquivalentAddressGroup> servers = List<EquivalentAddressGroup> servers =
createWeightedServerAddrs(Integer.MAX_VALUE, 10, 100); // MAX:10:100 createWeightedServerAddrs(Integer.MAX_VALUE, 10, 100); // MAX:10:100
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
// Try value between max signed and max unsigned int // Try value between max signed and max unsigned int
servers = createWeightedServerAddrs(Integer.MAX_VALUE + 100L, 100); // (MAX+100):100 servers = createWeightedServerAddrs(Integer.MAX_VALUE + 100L, 100); // (MAX+100):100
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
// Try a negative value // Try a negative value
servers = createWeightedServerAddrs(10, -20, 100); // 10:-20:100 servers = createWeightedServerAddrs(10, -20, 100); // 10:-20:100
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isFalse(); assertThat(addressesAcceptanceStatus.isOk()).isFalse();
// Try an individual value larger than max unsigned int // Try an individual value larger than max unsigned int
long maxUnsigned = UnsignedInteger.MAX_VALUE.longValue(); long maxUnsigned = UnsignedInteger.MAX_VALUE.longValue();
servers = createWeightedServerAddrs(maxUnsigned + 10, 10, 100); // uMAX+10:10:100 servers = createWeightedServerAddrs(maxUnsigned + 10, 10, 100); // uMAX+10:10:100
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isFalse(); assertThat(addressesAcceptanceStatus.isOk()).isFalse();
// Try a sum of values larger than max unsigned int // Try a sum of values larger than max unsigned int
servers = createWeightedServerAddrs(Integer.MAX_VALUE, Integer.MAX_VALUE, 100); // MAX:MAX:100 servers = createWeightedServerAddrs(Integer.MAX_VALUE, Integer.MAX_VALUE, 100); // MAX:MAX:100
addressesAccepted = loadBalancer.acceptResolvedAddresses( addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isFalse(); assertThat(addressesAcceptanceStatus.isOk()).isFalse();
} }
@Test @Test
public void hostSelectionProportionalToWeights() { public void hostSelectionProportionalToWeights() {
RingHashConfig config = new RingHashConfig(10000, 100000); // large ring RingHashConfig config = new RingHashConfig(10000, 100000); // large ring
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 10, 100); // 1:10:100 List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 10, 100); // 1:10:100
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class)); verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
@ -1059,10 +1059,10 @@ public class RingHashLoadBalancerTest {
public void nameResolutionErrorWithActiveSubchannels() { public void nameResolutionErrorWithActiveSubchannels() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1); List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isTrue(); assertThat(addressesAcceptanceStatus.isOk()).isTrue();
verify(helper).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture()); verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
@ -1083,10 +1083,10 @@ public class RingHashLoadBalancerTest {
public void duplicateAddresses() { public void duplicateAddresses() {
RingHashConfig config = new RingHashConfig(10, 100); RingHashConfig config = new RingHashConfig(10, 100);
List<EquivalentAddressGroup> servers = createRepeatedServerAddrs(1, 2, 3); List<EquivalentAddressGroup> servers = createRepeatedServerAddrs(1, 2, 3);
boolean addressesAccepted = loadBalancer.acceptResolvedAddresses( Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(config).build()); .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
assertThat(addressesAccepted).isFalse(); assertThat(addressesAcceptanceStatus.isOk()).isFalse();
verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture()); verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
PickSubchannelArgs args = new PickSubchannelArgsImpl( PickSubchannelArgs args = new PickSubchannelArgsImpl(

2
xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerTest.java
View File

@ -467,7 +467,7 @@ public class WeightedRoundRobinLoadBalancerTest {
public void emptyConfig() { public void emptyConfig() {
assertThat(wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder() assertThat(wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
.setAddresses(servers).setLoadBalancingPolicyConfig(null) .setAddresses(servers).setLoadBalancingPolicyConfig(null)
.setAttributes(affinity).build())).isFalse(); .setAttributes(affinity).build()).isOk()).isFalse();
verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class)); verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
verify(helper).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any()); verify(helper).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
assertThat(fakeClock.getPendingTasks()).isEmpty(); assertThat(fakeClock.getPendingTasks()).isEmpty();