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.
* @since 1.49.0
*/
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
if (resolvedAddresses.getAddresses().isEmpty()
&& !canHandleEmptyAddressListFromNameResolution()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes()));
return false;
Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes());
handleNameResolutionError(unavailableStatus);
return unavailableStatus;
} else {
if (recursionCount++ == 0) {
handleResolvedAddresses(resolvedAddresses);
}
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() {
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
resultCapture.set(resolvedAddresses);
return true;
return Status.OK;
}
@Override

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

@ -70,8 +70,8 @@ public final class AutoConfiguredLoadBalancerFactory {
}
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return true;
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return Status.OK;
}
@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
* support an empty list).
*/
boolean tryAcceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
Status tryAcceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
PolicySelection policySelection =
(PolicySelection) resolvedAddresses.getLoadBalancingPolicyConfig();
@ -116,7 +116,7 @@ public final class AutoConfiguredLoadBalancerFactory {
delegate.shutdown();
delegateProvider = null;
delegate = new NoopLoadBalancer();
return true;
return Status.OK;
}
policySelection =
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().
onError(configOrError.getError());
if (resolutionResultListener != null) {
resolutionResultListener.resolutionAttempted(false);
resolutionResultListener.resolutionAttempted(configOrError.getError());
}
return;
} else {
@ -1851,7 +1851,7 @@ final class ManagedChannelImpl extends ManagedChannel implements
}
Attributes attributes = attrBuilder.build();
boolean lastAddressesAccepted = helper.lb.tryAcceptResolvedAddresses(
Status addressAcceptanceStatus = helper.lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder()
.setAddresses(servers)
.setAttributes(attributes)
@ -1859,7 +1859,7 @@ final class ManagedChannelImpl extends ManagedChannel implements
.build());
// If a listener is provided, let it know if the addresses were accepted.
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
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
if (servers.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes()));
return false;
Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes());
handleNameResolutionError(unavailableStatus);
return unavailableStatus;
}
for (EquivalentAddressGroup eag : servers) {
if (eag == null) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription(
Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned address list with null endpoint. addrs="
+ resolvedAddresses.getAddresses() + ", attrs=" + resolvedAddresses.getAttributes()));
return false;
+ resolvedAddresses.getAddresses() + ", attrs="
+ resolvedAddresses.getAttributes());
handleNameResolutionError(unavailableStatus);
return unavailableStatus;
}
}
// 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();
addressIndex.updateGroups(newImmutableAddressGroups);
if (addressIndex.seekTo(previousAddress)) {
return true;
return Status.OK;
}
addressIndex.reset();
} else {
@ -144,7 +147,7 @@ final class PickFirstLeafLoadBalancer extends LoadBalancer {
requestConnection();
}
return true;
return Status.OK;
}
@Override

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

@ -50,13 +50,14 @@ final class PickFirstLoadBalancer extends LoadBalancer {
}
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
if (servers.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes()));
return false;
Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes());
handleNameResolutionError(unavailableStatus);
return unavailableStatus;
}
// 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);
}
return true;
return Status.OK;
}
@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.
*/
class ResolutionResultListener {
public void resolutionAttempted(boolean successful) {
if (successful) {
public void resolutionAttempted(Status successStatus) {
if (successStatus.isOk()) {
retryScheduler.reset();
} else {
retryScheduler.schedule(new DelayedNameResolverRefresh());

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

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

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

@ -316,7 +316,8 @@ public class ManagedChannelImplTest {
@Before
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);
expectedUri = new URI(TARGET);
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(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
assertFalse(loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder()
.setAddresses(Arrays.<EquivalentAddressGroup>asList()).setAttributes(affinity).build()));
ResolvedAddresses.newBuilder().setAddresses(Arrays.<EquivalentAddressGroup>asList())
.setAttributes(affinity).build()).isOk());
assertEquals(TRANSIENT_FAILURE, loadBalancer.getCurrentState());
}
@ -573,7 +573,7 @@ public class PickFirstLeafLoadBalancerTest {
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
List<EquivalentAddressGroup> eags = Arrays.asList((EquivalentAddressGroup) null);
assertFalse(loadBalancer.acceptResolvedAddresses(
ResolvedAddresses.newBuilder().setAddresses(eags).setAttributes(affinity).build()));
ResolvedAddresses.newBuilder().setAddresses(eags).setAttributes(affinity).build()).isOk());
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);
assertThat(resolutionResultListener).isNotNull();
resolutionResultListener.resolutionAttempted(true);
resolutionResultListener.resolutionAttempted(Status.OK);
verify(mockRetryScheduler).reset();
}
@ -108,7 +108,7 @@ public class RetryingNameResolverTest {
.get(RetryingNameResolver.RESOLUTION_RESULT_LISTENER_KEY);
assertThat(resolutionResultListener).isNotNull();
resolutionResultListener.resolutionAttempted(false);
resolutionResultListener.resolutionAttempted(Status.UNAVAILABLE);
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
public void setUp() throws Exception {
mockLoadBalancer.setAcceptAddresses(true);
mockLoadBalancer.setAddressAcceptanceStatus(Status.OK);
LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
expectedUri = new URI(TARGET);
when(mockTransportFactory.getScheduledExecutorService())
@ -280,7 +280,7 @@ public class ServiceConfigErrorHandlingTest {
nameResolverFactory.servers.clear();
// 2nd resolution
mockLoadBalancer.setAcceptAddresses(false);
mockLoadBalancer.setAddressAcceptanceStatus(Status.UNAVAILABLE);
nameResolverFactory.allResolved();
// 2nd service config without addresses
@ -649,7 +649,7 @@ public class ServiceConfigErrorHandlingTest {
private static class FakeLoadBalancer extends LoadBalancer {
private boolean acceptAddresses = true;
private Status addressAcceptanceStatus = Status.OK;
@Nullable
private Helper helper;
@ -659,12 +659,12 @@ public class ServiceConfigErrorHandlingTest {
}
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return acceptAddresses;
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return addressAcceptanceStatus;
}
public void setAcceptAddresses(boolean acceptAddresses) {
this.acceptAddresses = acceptAddresses;
public void setAddressAcceptanceStatus(Status addressAcceptanceStatus) {
this.addressAcceptanceStatus = addressAcceptanceStatus;
}
@Override

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

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

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

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

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

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

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

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

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

@ -703,7 +703,7 @@ public class CachingRlsLbClientTest {
LoadBalancer loadBalancer = new LoadBalancer() {
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
Map<?, ?> config = (Map<?, ?>) resolvedAddresses.getLoadBalancingPolicyConfig();
if (DEFAULT_TARGET.equals(config.get("target"))) {
helper.updateBalancingState(
@ -727,7 +727,7 @@ public class CachingRlsLbClientTest {
});
}
return true;
return Status.OK;
}
@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.LoadBalancerRegistry;
import io.grpc.NameResolver.ConfigOrError;
import io.grpc.Status;
import io.grpc.SynchronizationContext;
import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
import io.grpc.rls.LbPolicyConfiguration.ChildLbStatusListener;
@ -95,6 +96,7 @@ public class LbPolicyConfigurationTest {
doReturn(lb).when(lbProvider).newLoadBalancer(any(Helper.class));
doReturn(ConfigOrError.fromConfig(new Object()))
.when(lbProvider).parseLoadBalancingPolicyConfig(ArgumentMatchers.<Map<String, ?>>any());
doReturn(Status.OK).when(lb).acceptResolvedAddresses(any(ResolvedAddresses.class));
}
@Test
@ -123,7 +125,7 @@ public class LbPolicyConfigurationTest {
@Test
public void childPolicyWrapper_addressesRejected() {
when(lb.acceptResolvedAddresses(any(ResolvedAddresses.class))).thenReturn(false);
when(lb.acceptResolvedAddresses(any(ResolvedAddresses.class))).thenReturn(Status.UNAVAILABLE);
factory.createOrGet("target");
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
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
try {
resolvingAddresses = true;
return acceptResolvedAddressesInternal(resolvedAddresses);
@ -183,14 +183,15 @@ public abstract class MultiChildLoadBalancer extends LoadBalancer {
.build();
}
private boolean acceptResolvedAddressesInternal(ResolvedAddresses resolvedAddresses) {
private Status acceptResolvedAddressesInternal(ResolvedAddresses resolvedAddresses) {
logger.log(Level.FINE, "Received resolution result: {0}", resolvedAddresses);
Map<Object, ChildLbState> newChildren = createChildLbMap(resolvedAddresses);
if (newChildren.isEmpty()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. " + resolvedAddresses));
return false;
Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. " + resolvedAddresses);
handleNameResolutionError(unavailableStatus);
return unavailableStatus;
}
// 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
// clusters and resolver can remove them in service config.
updateOverallBalancingState();
return true;
return Status.OK;
}
@Override

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

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

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

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

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

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

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

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

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

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

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

@ -82,7 +82,7 @@ final class LeastRequestLoadBalancer extends MultiChildLoadBalancer {
}
@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
// new value. However, if the update fails we need to revert it.
int oldChoiceCount = choiceCount;
@ -92,13 +92,13 @@ final class LeastRequestLoadBalancer extends MultiChildLoadBalancer {
choiceCount = config.choiceCount;
}
boolean successfulUpdate = super.acceptResolvedAddresses(resolvedAddresses);
Status addressAcceptanceStatus = super.acceptResolvedAddresses(resolvedAddresses);
if (!successfulUpdate) {
if (!addressAcceptanceStatus.isOk()) {
choiceCount = oldChoiceCount;
}
return successfulUpdate;
return addressAcceptanceStatus;
}
@Override

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

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

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

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

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

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

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

@ -59,7 +59,7 @@ final class WeightedTargetLoadBalancer extends LoadBalancer {
}
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
try {
resolvingAddresses = true;
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);
Object lbConfig = resolvedAddresses.getLoadBalancingPolicyConfig();
checkNotNull(lbConfig, "missing weighted_target lb config");
@ -107,7 +107,7 @@ final class WeightedTargetLoadBalancer extends LoadBalancer {
childBalancers.keySet().retainAll(targets.keySet());
childHelpers.keySet().retainAll(targets.keySet());
updateOverallBalancingState();
return true;
return Status.OK;
}
@Override

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

@ -62,7 +62,7 @@ final class WrrLocalityLoadBalancer extends LoadBalancer {
}
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
// 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);
if (locality == null) {
helper.updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(
Status.UNAVAILABLE.withDescription("wrr_locality error: no locality provided"))));
return false;
Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"wrr_locality error: no locality provided");
helper.updateBalancingState(TRANSIENT_FAILURE,
new FixedResultPicker(PickResult.withError(unavailableStatus)));
return unavailableStatus;
}
if (localityWeight == null) {
helper.updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(
Status.UNAVAILABLE.withDescription(
"wrr_locality error: no weight provided for locality " + locality))));
return false;
Status unavailableStatus = Status.UNAVAILABLE.withDescription(
"wrr_locality error: no weight provided for locality " + locality);
helper.updateBalancingState(TRANSIENT_FAILURE,
new FixedResultPicker(PickResult.withError(unavailableStatus)));
return unavailableStatus;
}
if (!localityWeights.containsKey(locality)) {
@ -113,7 +116,7 @@ final class WrrLocalityLoadBalancer extends LoadBalancer {
.setLoadBalancingPolicyConfig(new WeightedTargetConfig(weightedPolicySelections))
.build());
return true;
return Status.OK;
}
@Override

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

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

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

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

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

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

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

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

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

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