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

api,core: Add LoadBalancer.acceptResolvedAddresses() (#9498) 

Introduces a new acceptResolvedAddresses() method in LoadBalancer that
is to ultimately replace the existing handleResolvedAddresses(). The new
method allows the LoadBalancer implementation to reject the given
addresses by returning false from the method.

The long deprecated handleResolvedAddressGroups is also removed.
This commit is contained in:
Terry Wilson 2022-08-31 08:36:50 -07:00 committed by GitHub
parent 8dbff5ba6a
commit 4b4cb0bd3b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 183 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -124,39 +124,46 @@ public abstract class LoadBalancer {
* *
* <p>Implementations should not modify the given {@code servers}. * <p>Implementations should not modify the given {@code servers}.
* *
* @param servers the resolved server addresses, never empty. * @param resolvedAddresses the resolved server addresses, attributes, and config.
* @param attributes extra information from naming system. * @since 1.21.0
* @deprecated override {@link #handleResolvedAddresses(ResolvedAddresses) instead}
* @since 1.2.0
*/ */
@Deprecated public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public void handleResolvedAddressGroups(
List<EquivalentAddressGroup> servers,
@NameResolver.ResolutionResultAttr Attributes attributes) {
if (recursionCount++ == 0) { if (recursionCount++ == 0) {
handleResolvedAddresses( // Note that the information about the addresses actually being accepted will be lost
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attributes).build()); // if you rely on this method for backward compatibility.
acceptResolvedAddresses(resolvedAddresses);
} }
recursionCount = 0; recursionCount = 0;
} }
/** /**
* Handles newly resolved server groups and metadata attributes from name resolution system. * Accepts newly resolved addresses from the name resolution system. The {@link
* {@code servers} contained in {@link EquivalentAddressGroup} should be considered equivalent * EquivalentAddressGroup} addresses should be considered equivalent but may be flattened into a
* but may be flattened into a single list if needed. * single list if needed.
* *
* <p>Implementations should not modify the given {@code servers}. * <p>Implementations can choose to reject the given addresses by returning {@code false}.
*
* <p>Implementations should not modify the given {@code addresses}.
* *
* @param resolvedAddresses the resolved server addresses, attributes, and config. * @param resolvedAddresses the resolved server addresses, attributes, and config.
* @since 1.21.0 * @return {@code true} if the resolved addresses were accepted. {@code false} if rejected.
* @since 1.49.0
*/ */
@SuppressWarnings("deprecation") public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) { if (resolvedAddresses.getAddresses().isEmpty()
&& !canHandleEmptyAddressListFromNameResolution()) {
handleNameResolutionError(Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+ ", attrs=" + resolvedAddresses.getAttributes()));
return false;
} else {
if (recursionCount++ == 0) { if (recursionCount++ == 0) {
handleResolvedAddressGroups( handleResolvedAddresses(resolvedAddresses);
resolvedAddresses.getAddresses(), resolvedAddresses.getAttributes());
} }
recursionCount = 0; recursionCount = 0;
return true;
}
} }
/** /**

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

@ -235,13 +235,14 @@ public class LoadBalancerTest {
@Deprecated @Deprecated
@Test @Test
public void handleResolvedAddressGroups_delegatesToHandleResolvedAddresses() { public void handleResolvedAddresses_delegatesToAcceptResolvedAddresses() {
final AtomicReference<ResolvedAddresses> resultCapture = new AtomicReference<>(); final AtomicReference<ResolvedAddresses> resultCapture = new AtomicReference<>();
LoadBalancer balancer = new LoadBalancer() { LoadBalancer balancer = new LoadBalancer() {
@Override @Override
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) { public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
resultCapture.set(resolvedAddresses); resultCapture.set(resolvedAddresses);
return true;
} }
@Override @Override
@ -260,23 +261,22 @@ public class LoadBalancerTest {
List<EquivalentAddressGroup> servers = Arrays.asList( List<EquivalentAddressGroup> servers = Arrays.asList(
new EquivalentAddressGroup(new SocketAddress(){}), new EquivalentAddressGroup(new SocketAddress(){}),
new EquivalentAddressGroup(new SocketAddress(){})); new EquivalentAddressGroup(new SocketAddress(){}));
balancer.handleResolvedAddressGroups(servers, attrs); ResolvedAddresses addresses = ResolvedAddresses.newBuilder().setAddresses(servers)
.setAttributes(attrs).build();
balancer.handleResolvedAddresses(addresses);
assertThat(resultCapture.get()).isEqualTo( assertThat(resultCapture.get()).isEqualTo(
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attrs).build()); ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attrs).build());
} }
@Deprecated @Deprecated
@Test @Test
public void handleResolvedAddresses_delegatesToHandleResolvedAddressGroups() { public void acceptResolvedAddresses_delegatesToHandleResolvedAddressGroups() {
final AtomicReference<List<EquivalentAddressGroup>> serversCapture = new AtomicReference<>(); final AtomicReference<ResolvedAddresses> addressesCapture = new AtomicReference<>();
final AtomicReference<Attributes> attrsCapture = new AtomicReference<>();
LoadBalancer balancer = new LoadBalancer() { LoadBalancer balancer = new LoadBalancer() {
@Override @Override
public void handleResolvedAddressGroups( public void handleResolvedAddresses(ResolvedAddresses addresses) {
List<EquivalentAddressGroup> servers, Attributes attrs) { addressesCapture.set(addresses);
serversCapture.set(servers);
attrsCapture.set(attrs);
} }
@Override @Override
@ -295,25 +295,23 @@ public class LoadBalancerTest {
List<EquivalentAddressGroup> servers = Arrays.asList( List<EquivalentAddressGroup> servers = Arrays.asList(
new EquivalentAddressGroup(new SocketAddress(){}), new EquivalentAddressGroup(new SocketAddress(){}),
new EquivalentAddressGroup(new SocketAddress(){})); new EquivalentAddressGroup(new SocketAddress(){}));
balancer.handleResolvedAddresses( ResolvedAddresses addresses = ResolvedAddresses.newBuilder().setAddresses(servers)
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attrs).build()); .setAttributes(attrs).build();
assertThat(serversCapture.get()).isEqualTo(servers); balancer.handleResolvedAddresses(addresses);
assertThat(attrsCapture.get()).isEqualTo(attrs); assertThat(addressesCapture.get().getAddresses()).isEqualTo(servers);
assertThat(addressesCapture.get().getAttributes()).isEqualTo(attrs);
} }
@Deprecated @Deprecated
@Test @Test
public void handleResolvedAddresses_noInfiniteLoop() { public void acceptResolvedAddresses_noInfiniteLoop() {
final List<List<EquivalentAddressGroup>> serversCapture = new ArrayList<>(); final List<ResolvedAddresses> addressesCapture = new ArrayList<>();
final List<Attributes> attrsCapture = new ArrayList<>();
LoadBalancer balancer = new LoadBalancer() { LoadBalancer balancer = new LoadBalancer() {
@Override @Override
public void handleResolvedAddressGroups( public void handleResolvedAddresses(ResolvedAddresses addresses) {
List<EquivalentAddressGroup> servers, Attributes attrs) { addressesCapture.add(addresses);
serversCapture.add(servers); super.handleResolvedAddresses(addresses);
attrsCapture.add(attrs);
super.handleResolvedAddressGroups(servers, attrs);
} }
@Override @Override
@ -328,12 +326,12 @@ public class LoadBalancerTest {
List<EquivalentAddressGroup> servers = Arrays.asList( List<EquivalentAddressGroup> servers = Arrays.asList(
new EquivalentAddressGroup(new SocketAddress(){}), new EquivalentAddressGroup(new SocketAddress(){}),
new EquivalentAddressGroup(new SocketAddress(){})); new EquivalentAddressGroup(new SocketAddress(){}));
balancer.handleResolvedAddresses( ResolvedAddresses addresses = ResolvedAddresses.newBuilder().setAddresses(servers)
ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attrs).build()); .setAttributes(attrs).build();
assertThat(serversCapture).hasSize(1); balancer.handleResolvedAddresses(addresses);
assertThat(attrsCapture).hasSize(1); assertThat(addressesCapture).hasSize(1);
assertThat(serversCapture.get(0)).isEqualTo(servers); assertThat(addressesCapture.get(0).getAddresses()).isEqualTo(servers);
assertThat(attrsCapture.get(0)).isEqualTo(attrs); assertThat(addressesCapture.get(0).getAttributes()).isEqualTo(attrs);
} }
private static class NoopHelper extends LoadBalancer.Helper { private static class NoopHelper extends LoadBalancer.Helper {

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

@ -20,11 +20,9 @@ import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.VisibleForTesting; import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects; import com.google.common.base.MoreObjects;
import io.grpc.Attributes;
import io.grpc.ChannelLogger.ChannelLogLevel; import io.grpc.ChannelLogger.ChannelLogLevel;
import io.grpc.ConnectivityState; import io.grpc.ConnectivityState;
import io.grpc.ConnectivityStateInfo; import io.grpc.ConnectivityStateInfo;
import io.grpc.EquivalentAddressGroup;
import io.grpc.LoadBalancer; import io.grpc.LoadBalancer;
import io.grpc.LoadBalancer.Helper; import io.grpc.LoadBalancer.Helper;
import io.grpc.LoadBalancer.PickResult; import io.grpc.LoadBalancer.PickResult;
@ -67,10 +65,14 @@ public final class AutoConfiguredLoadBalancerFactory {
@Override @Override
@Deprecated @Deprecated
public void handleResolvedAddressGroups(List<EquivalentAddressGroup> s, Attributes a) {} @SuppressWarnings("InlineMeSuggester")
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
}
@Override @Override
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {} public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return true;
}
@Override @Override
public void handleNameResolutionError(Status error) {} public void handleNameResolutionError(Status error) {}
@ -97,14 +99,10 @@ public final class AutoConfiguredLoadBalancerFactory {
} }
/** /**
* Returns non-OK status if resolvedAddresses is empty and delegate lb requires address ({@link * Returns non-OK status if the delegate rejects the resolvedAddresses (e.g. if it does not
* LoadBalancer#canHandleEmptyAddressListFromNameResolution()} returns {@code false}). {@code * support an empty list).
* AutoConfiguredLoadBalancer} doesn't expose {@code
* canHandleEmptyAddressListFromNameResolution} because it depends on the delegated LB.
*/ */
Status tryHandleResolvedAddresses(ResolvedAddresses resolvedAddresses) { boolean tryAcceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
Attributes attributes = resolvedAddresses.getAttributes();
PolicySelection policySelection = PolicySelection policySelection =
(PolicySelection) resolvedAddresses.getLoadBalancingPolicyConfig(); (PolicySelection) resolvedAddresses.getLoadBalancingPolicyConfig();
@ -118,7 +116,7 @@ public final class AutoConfiguredLoadBalancerFactory {
delegate.shutdown(); delegate.shutdown();
delegateProvider = null; delegateProvider = null;
delegate = new NoopLoadBalancer(); delegate = new NoopLoadBalancer();
return Status.OK; return true;
} }
policySelection = policySelection =
new PolicySelection(defaultProvider, /* config= */ null); new PolicySelection(defaultProvider, /* config= */ null);
@ -141,20 +139,12 @@ public final class AutoConfiguredLoadBalancerFactory {
ChannelLogLevel.DEBUG, "Load-balancing config: {0}", policySelection.config); ChannelLogLevel.DEBUG, "Load-balancing config: {0}", policySelection.config);
} }
LoadBalancer delegate = getDelegate(); return getDelegate().acceptResolvedAddresses(
if (resolvedAddresses.getAddresses().isEmpty()
&& !delegate.canHandleEmptyAddressListFromNameResolution()) {
return Status.UNAVAILABLE.withDescription(
"NameResolver returned no usable address. addrs=" + servers + ", attrs=" + attributes);
} else {
delegate.handleResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(resolvedAddresses.getAddresses()) .setAddresses(resolvedAddresses.getAddresses())
.setAttributes(attributes) .setAttributes(resolvedAddresses.getAttributes())
.setLoadBalancingPolicyConfig(lbConfig) .setLoadBalancingPolicyConfig(lbConfig)
.build()); .build());
return Status.OK;
}
} }
void handleNameResolutionError(Status error) { void handleNameResolutionError(Status error) {

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

@ -1852,16 +1852,17 @@ final class ManagedChannelImpl extends ManagedChannel implements
.set(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG, healthCheckingConfig) .set(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG, healthCheckingConfig)
.build(); .build();
} }
Attributes attributes = attrBuilder.build();
Status handleResult = helper.lb.tryHandleResolvedAddresses( boolean addressesAccepted = helper.lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setAttributes(attrBuilder.build()) .setAttributes(attributes)
.setLoadBalancingPolicyConfig(effectiveServiceConfig.getLoadBalancingConfig()) .setLoadBalancingPolicyConfig(effectiveServiceConfig.getLoadBalancingConfig())
.build()); .build());
if (!handleResult.isOk()) { if (!addressesAccepted) {
handleErrorInSyncContext(handleResult.augmentDescription(resolver + " was used")); scheduleExponentialBackOffInSyncContext();
} }
} }
} }

15
core/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
View File

@ -17,14 +17,10 @@
package io.grpc.util; package io.grpc.util;
import com.google.common.base.MoreObjects; import com.google.common.base.MoreObjects;
import io.grpc.Attributes;
import io.grpc.ConnectivityStateInfo; import io.grpc.ConnectivityStateInfo;
import io.grpc.EquivalentAddressGroup;
import io.grpc.ExperimentalApi; import io.grpc.ExperimentalApi;
import io.grpc.LoadBalancer; import io.grpc.LoadBalancer;
import io.grpc.NameResolver;
import io.grpc.Status; import io.grpc.Status;
import java.util.List;
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771") @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
public abstract class ForwardingLoadBalancer extends LoadBalancer { public abstract class ForwardingLoadBalancer extends LoadBalancer {
@ -34,16 +30,13 @@ public abstract class ForwardingLoadBalancer extends LoadBalancer {
protected abstract LoadBalancer delegate(); protected abstract LoadBalancer delegate();
@Override @Override
@Deprecated public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
public void handleResolvedAddressGroups( delegate().handleResolvedAddresses(resolvedAddresses);
List<EquivalentAddressGroup> servers,
@NameResolver.ResolutionResultAttr Attributes attributes) {
delegate().handleResolvedAddressGroups(servers, attributes);
} }
@Override @Override
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) { public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
delegate().handleResolvedAddresses(resolvedAddresses); return delegate().acceptResolvedAddresses(resolvedAddresses);
} }
@Override @Override

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

@ -21,8 +21,8 @@ import static org.junit.Assert.assertTrue;
import static org.mockito.AdditionalAnswers.delegatesTo; import static org.mockito.AdditionalAnswers.delegatesTo;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.ArgumentMatchers.same; import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times; import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
@ -97,9 +97,8 @@ public class AutoConfiguredLoadBalancerFactoryTest {
@Before @Before
public void setUp() { public void setUp() {
when(testLbBalancer.canHandleEmptyAddressListFromNameResolution()).thenCallRealMethod(); when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(true);
assertThat(testLbBalancer.canHandleEmptyAddressListFromNameResolution()).isFalse(); when(testLbBalancer2.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(true);
when(testLbBalancer2.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
defaultRegistry.register(testLbBalancerProvider); defaultRegistry.register(testLbBalancerProvider);
defaultRegistry.register(testLbBalancerProvider2); defaultRegistry.register(testLbBalancerProvider2);
} }
@ -171,7 +170,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
} }
@Test @Test
public void handleResolvedAddressGroups_keepOldBalancer() { public void acceptResolvedAddresses_keepOldBalancer() {
final List<EquivalentAddressGroup> servers = final List<EquivalentAddressGroup> servers =
Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){})); Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
Helper helper = new TestHelper() { Helper helper = new TestHelper() {
@ -184,19 +183,19 @@ public class AutoConfiguredLoadBalancerFactoryTest {
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
LoadBalancer oldDelegate = lb.getDelegate(); LoadBalancer oldDelegate = lb.getDelegate();
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setAttributes(Attributes.EMPTY) .setAttributes(Attributes.EMPTY)
.setLoadBalancingPolicyConfig(null) .setLoadBalancingPolicyConfig(null)
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate); assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate);
} }
@Test @Test
public void handleResolvedAddressGroups_shutsDownOldBalancer() throws Exception { public void acceptResolvedAddresses_shutsDownOldBalancer() throws Exception {
Map<String, ?> serviceConfig = Map<String, ?> serviceConfig =
parseConfig("{\"loadBalancingConfig\": [ {\"round_robin\": { } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"round_robin\": { } } ] }");
ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig); ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(serviceConfig);
@ -226,13 +225,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
}; };
lb.setDelegate(testlb); lb.setDelegate(testlb);
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).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());
@ -240,7 +239,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
@Test @Test
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public void handleResolvedAddressGroups_propagateLbConfigToDelegate() throws Exception { public void acceptResolvedAddresses_propagateLbConfigToDelegate() throws Exception {
Map<String, ?> rawServiceConfig = Map<String, ?> rawServiceConfig =
parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig); ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
@ -251,20 +250,19 @@ public class AutoConfiguredLoadBalancerFactoryTest {
Helper helper = new TestHelper(); Helper helper = new TestHelper();
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = 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(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).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);
verify(testLbBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(testLbBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder(); assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
verify(testLbBalancer, atLeast(0)).canHandleEmptyAddressListFromNameResolution();
ArgumentCaptor<Map<String, ?>> lbConfigCaptor = ArgumentCaptor.forClass(Map.class); ArgumentCaptor<Map<String, ?>> lbConfigCaptor = ArgumentCaptor.forClass(Map.class);
verify(testLbBalancerProvider).parseLoadBalancingPolicyConfig(lbConfigCaptor.capture()); verify(testLbBalancerProvider).parseLoadBalancingPolicyConfig(lbConfigCaptor.capture());
assertThat(lbConfigCaptor.getValue()).containsExactly("setting1", "high"); assertThat(lbConfigCaptor.getValue()).containsExactly("setting1", "high");
@ -274,7 +272,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"low\" } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"low\" } } ] }");
lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig); lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
handleResult = lb.tryHandleResolvedAddresses( addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
@ -282,8 +280,8 @@ public class AutoConfiguredLoadBalancerFactoryTest {
resultCaptor = resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(testLbBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture()); verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).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());
@ -294,7 +292,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
} }
@Test @Test
public void handleResolvedAddressGroups_propagateAddrsToDelegate() throws Exception { public void acceptResolvedAddresses_propagateAddrsToDelegate() throws Exception {
Map<String, ?> rawServiceConfig = Map<String, ?> rawServiceConfig =
parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }"); parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig); ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
@ -305,56 +303,58 @@ public class AutoConfiguredLoadBalancerFactoryTest {
List<EquivalentAddressGroup> servers = List<EquivalentAddressGroup> servers =
Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(8080){})); Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(8080){}));
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = 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(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).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);
verify(testLbBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(testLbBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder(); assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
servers = servers =
Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(9090){})); Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(9090){}));
handleResult = lb.tryHandleResolvedAddresses( addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
verify(testLbBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture()); verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder(); assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
} }
@Test @Test
public void handleResolvedAddressGroups_delegateDoNotAcceptEmptyAddressList_nothing() public void acceptResolvedAddresses_delegateDoNotAcceptEmptyAddressList_nothing()
throws Exception { throws Exception {
// The test LB will NOT accept the addresses we give them.
when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(false);
Helper helper = new TestHelper(); Helper helper = new TestHelper();
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
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);
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(Collections.<EquivalentAddressGroup>emptyList()) .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
.setLoadBalancingPolicyConfig(lbConfig.getConfig()) .setLoadBalancingPolicyConfig(lbConfig.getConfig())
.build()); .build());
assertThat(testLbBalancer.canHandleEmptyAddressListFromNameResolution()).isFalse(); assertThat(addressesAccepted).isFalse();
assertThat(handleResult.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
assertThat(handleResult.getDescription()).startsWith("NameResolver returned no usable address");
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
} }
@Test @Test
public void handleResolvedAddressGroups_delegateAcceptsEmptyAddressList() public void acceptResolvedAddresses_delegateAcceptsEmptyAddressList()
throws Exception { throws Exception {
Helper helper = new TestHelper(); Helper helper = new TestHelper();
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
@ -363,25 +363,24 @@ 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);
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(Collections.<EquivalentAddressGroup>emptyList()) .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer2); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer2);
assertThat(testLbBalancer2.canHandleEmptyAddressListFromNameResolution()).isTrue();
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(testLbBalancer2).handleResolvedAddresses(resultCaptor.capture()); verify(testLbBalancer2).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).isEmpty(); assertThat(resultCaptor.getValue().getAddresses()).isEmpty();
assertThat(resultCaptor.getValue().getLoadBalancingPolicyConfig()) assertThat(resultCaptor.getValue().getLoadBalancingPolicyConfig())
.isEqualTo(nextParsedConfigOrError2.get().getConfig()); .isEqualTo(nextParsedConfigOrError2.get().getConfig());
} }
@Test @Test
public void handleResolvedAddressGroups_useSelectedLbPolicy() throws Exception { public void acceptResolvedAddresses_useSelectedLbPolicy() throws Exception {
Map<String, ?> rawServiceConfig = Map<String, ?> rawServiceConfig =
parseConfig("{\"loadBalancingConfig\": [{\"round_robin\": {}}]}"); parseConfig("{\"loadBalancingConfig\": [{\"round_robin\": {}}]}");
ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig); ConfigOrError lbConfigs = lbf.parseLoadBalancerPolicy(rawServiceConfig);
@ -399,18 +398,18 @@ public class AutoConfiguredLoadBalancerFactoryTest {
} }
}; };
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
assertThat(lb.getDelegate().getClass().getName()) assertThat(lb.getDelegate().getClass().getName())
.isEqualTo("io.grpc.util.RoundRobinLoadBalancer"); .isEqualTo("io.grpc.util.RoundRobinLoadBalancer");
} }
@Test @Test
public void handleResolvedAddressGroups_noLbPolicySelected_defaultToPickFirst() { public void acceptResolvedAddresses_noLbPolicySelected_defaultToPickFirst() {
final List<EquivalentAddressGroup> servers = final List<EquivalentAddressGroup> servers =
Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){})); Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
Helper helper = new TestHelper() { Helper helper = new TestHelper() {
@ -421,27 +420,27 @@ public class AutoConfiguredLoadBalancerFactoryTest {
} }
}; };
AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper); AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(null) .setLoadBalancingPolicyConfig(null)
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
assertThat(lb.getDelegate()).isInstanceOf(PickFirstLoadBalancer.class); assertThat(lb.getDelegate()).isInstanceOf(PickFirstLoadBalancer.class);
} }
@Test @Test
public void handleResolvedAddressGroups_noLbPolicySelected_defaultToCustomDefault() { public void acceptResolvedAddresses_noLbPolicySelected_defaultToCustomDefault() {
AutoConfiguredLoadBalancer lb = new AutoConfiguredLoadBalancerFactory("test_lb") AutoConfiguredLoadBalancer lb = new AutoConfiguredLoadBalancerFactory("test_lb")
.newLoadBalancer(new TestHelper()); .newLoadBalancer(new TestHelper());
List<EquivalentAddressGroup> servers = List<EquivalentAddressGroup> servers =
Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){})); Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(null) .setLoadBalancingPolicyConfig(null)
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer); assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
} }
@ -458,13 +457,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
AutoConfiguredLoadBalancer lb = AutoConfiguredLoadBalancer lb =
new AutoConfiguredLoadBalancerFactory(GrpcUtil.DEFAULT_LB_POLICY).newLoadBalancer(helper); new AutoConfiguredLoadBalancerFactory(GrpcUtil.DEFAULT_LB_POLICY).newLoadBalancer(helper);
Status handleResult = lb.tryHandleResolvedAddresses( boolean addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setAttributes(Attributes.EMPTY) .setAttributes(Attributes.EMPTY)
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
verifyNoMoreInteractions(channelLogger); verifyNoMoreInteractions(channelLogger);
ConfigOrError testLbParsedConfig = ConfigOrError.fromConfig("foo"); ConfigOrError testLbParsedConfig = ConfigOrError.fromConfig("foo");
@ -472,13 +471,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);
handleResult = lb.tryHandleResolvedAddresses( addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).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}"),
@ -495,12 +494,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);
handleResult = lb.tryHandleResolvedAddresses( addressesAccepted = lb.tryAcceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(servers) .setAddresses(servers)
.setLoadBalancingPolicyConfig(lbConfigs.getConfig()) .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
.build()); .build());
assertThat(handleResult.getCode()).isEqualTo(Status.Code.OK); assertThat(addressesAccepted).isTrue();
verify(channelLogger).log( verify(channelLogger).log(
eq(ChannelLogLevel.DEBUG), eq(ChannelLogLevel.DEBUG),
eq("Load-balancing config: {0}"), eq("Load-balancing config: {0}"),
@ -643,14 +642,13 @@ public class AutoConfiguredLoadBalancerFactoryTest {
@Override @Override
@Deprecated @Deprecated
public void handleResolvedAddressGroups( public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
List<EquivalentAddressGroup> servers, Attributes attributes) { delegate().acceptResolvedAddresses(resolvedAddresses);
delegate().handleResolvedAddressGroups(servers, attributes);
} }
@Override @Override
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) { public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
delegate().handleResolvedAddresses(resolvedAddresses); return delegate().acceptResolvedAddresses(resolvedAddresses);
} }
@Override @Override

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

@ -154,6 +154,7 @@ 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);
LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider); LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
when(mockNameResolver.getServiceAuthority()).thenReturn(AUTHORITY); when(mockNameResolver.getServiceAuthority()).thenReturn(AUTHORITY);
when(mockNameResolverFactory when(mockNameResolverFactory
@ -220,7 +221,7 @@ public class ManagedChannelImplIdlenessTest {
ArgumentCaptor<ResolvedAddresses> resolvedAddressCaptor = ArgumentCaptor<ResolvedAddresses> resolvedAddressCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
assertThat(resolvedAddressCaptor.getValue().getAddresses()) assertThat(resolvedAddressCaptor.getValue().getAddresses())
.containsExactlyElementsIn(servers); .containsExactlyElementsIn(servers);
} }

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

@ -323,7 +323,7 @@ public class ManagedChannelImplTest {
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenCallRealMethod(); when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(true);
LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider); LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
expectedUri = new URI(TARGET); expectedUri = new URI(TARGET);
transports = TestUtils.captureTransports(mockTransportFactory); transports = TestUtils.captureTransports(mockTransportFactory);
@ -928,7 +928,7 @@ public class ManagedChannelImplTest {
FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0); FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class)); verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
SubchannelStateListener stateListener1 = mock(SubchannelStateListener.class); SubchannelStateListener stateListener1 = mock(SubchannelStateListener.class);
@ -1143,8 +1143,9 @@ public class ManagedChannelImplTest {
} }
@Test @Test
public void nameResolverReturnsEmptySubLists_becomeErrorByDefault() throws Exception { public void nameResolverReturnsEmptySubLists_resolutionRetry() throws Exception {
String errorDescription = "NameResolver returned no usable address"; // The mock LB is set to reject the addresses.
when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(false);
// Pass a FakeNameResolverFactory with an empty list and LB config // Pass a FakeNameResolverFactory with an empty list and LB config
FakeNameResolverFactory nameResolverFactory = FakeNameResolverFactory nameResolverFactory =
@ -1157,21 +1158,12 @@ public class ManagedChannelImplTest {
channelBuilder.nameResolverFactory(nameResolverFactory); channelBuilder.nameResolverFactory(nameResolverFactory);
createChannel(); createChannel();
// LoadBalancer received the error
verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
verify(mockLoadBalancer).handleNameResolutionError(statusCaptor.capture());
Status status = statusCaptor.getValue();
assertSame(Status.Code.UNAVAILABLE, status.getCode());
assertThat(status.getDescription()).startsWith(errorDescription);
// A resolution retry has been scheduled // A resolution retry has been scheduled
assertEquals(1, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER)); assertEquals(1, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER));
} }
@Test @Test
public void nameResolverReturnsEmptySubLists_optionallyAllowed() throws Exception { public void nameResolverReturnsEmptySubLists_optionallyAllowed() throws Exception {
when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
// Pass a FakeNameResolverFactory with an empty list and LB config // Pass a FakeNameResolverFactory with an empty list and LB config
FakeNameResolverFactory nameResolverFactory = FakeNameResolverFactory nameResolverFactory =
new FakeNameResolverFactory.Builder(expectedUri).build(); new FakeNameResolverFactory.Builder(expectedUri).build();
@ -1193,7 +1185,7 @@ public class ManagedChannelImplTest {
verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class)); verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).isEmpty(); assertThat(resultCaptor.getValue().getAddresses()).isEmpty();
assertThat(resultCaptor.getValue().getLoadBalancingPolicyConfig()).isEqualTo(parsedLbConfig); assertThat(resultCaptor.getValue().getLoadBalancingPolicyConfig()).isEqualTo(parsedLbConfig);
@ -1214,7 +1206,7 @@ public class ManagedChannelImplTest {
createChannel(); createChannel();
verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class)); verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
doThrow(ex).when(mockLoadBalancer).handleResolvedAddresses(any(ResolvedAddresses.class)); doThrow(ex).when(mockLoadBalancer).acceptResolvedAddresses(any(ResolvedAddresses.class));
// NameResolver returns addresses. // NameResolver returns addresses.
nameResolverFactory.allResolved(); nameResolverFactory.allResolved();
@ -1276,7 +1268,7 @@ public class ManagedChannelImplTest {
// Simulate name resolution results // Simulate name resolution results
EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs); EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs);
inOrder.verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture()); inOrder.verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
Subchannel subchannel = Subchannel subchannel =
createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener); createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
@ -1426,7 +1418,7 @@ public class ManagedChannelImplTest {
// Simulate name resolution results // Simulate name resolution results
EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs); EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs);
inOrder.verify(mockLoadBalancer).handleResolvedAddresses(resolvedAddressCaptor.capture()); inOrder.verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
Subchannel subchannel = Subchannel subchannel =
@ -3655,7 +3647,7 @@ public class ManagedChannelImplTest {
ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class); ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture()); verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
helper = helperCaptor.getValue(); helper = helperCaptor.getValue();
verify(mockLoadBalancer).handleResolvedAddresses( verify(mockLoadBalancer).acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(nameResolverFactory.servers) .setAddresses(nameResolverFactory.servers)
.build()); .build());
@ -3761,7 +3753,7 @@ public class ManagedChannelImplTest {
ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class); ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture()); verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
helper = helperCaptor.getValue(); helper = helperCaptor.getValue();
verify(mockLoadBalancer).handleResolvedAddresses( verify(mockLoadBalancer).acceptResolvedAddresses(
ResolvedAddresses.newBuilder() ResolvedAddresses.newBuilder()
.setAddresses(nameResolverFactory.servers) .setAddresses(nameResolverFactory.servers)
.build()); .build());
@ -4088,7 +4080,7 @@ public class ManagedChannelImplTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull(); assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull();
verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class)); verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
@ -4126,7 +4118,7 @@ public class ManagedChannelImplTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull(); assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull();
verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class)); verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
@ -4156,7 +4148,7 @@ public class ManagedChannelImplTest {
createChannel(); createChannel();
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class)); verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
@ -4172,7 +4164,7 @@ public class ManagedChannelImplTest {
nameResolverFactory.allResolved(); nameResolverFactory.allResolved();
resultCaptor = ArgumentCaptor.forClass(ResolvedAddresses.class); resultCaptor = ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class)); verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
} finally { } finally {
@ -4206,7 +4198,7 @@ public class ManagedChannelImplTest {
createChannel(); createChannel();
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class)); verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
} finally { } finally {
@ -4234,7 +4226,7 @@ public class ManagedChannelImplTest {
createChannel(); createChannel();
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class)); verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
} finally { } finally {
@ -4260,7 +4252,7 @@ public class ManagedChannelImplTest {
createChannel(); createChannel();
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup); assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class)); verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
} finally { } finally {
@ -4340,7 +4332,7 @@ public class ManagedChannelImplTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
assertThat(resultCaptor.getValue().getAttributes() assertThat(resultCaptor.getValue().getAttributes()
.get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG)) .get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG))
.containsExactly("serviceName", "service1"); .containsExactly("serviceName", "service1");

49
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 {
when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenCallRealMethod(); mockLoadBalancer.setAcceptAddresses(true);
LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider); LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
expectedUri = new URI(TARGET); expectedUri = new URI(TARGET);
when(mockTransportFactory.getScheduledExecutorService()) when(mockTransportFactory.getScheduledExecutorService())
@ -268,7 +268,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("12"); assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("12");
@ -280,19 +280,14 @@ public class ServiceConfigErrorHandlingTest {
nameResolverFactory.servers.clear(); nameResolverFactory.servers.clear();
// 2nd resolution // 2nd resolution
mockLoadBalancer.setAcceptAddresses(false);
nameResolverFactory.allResolved(); nameResolverFactory.allResolved();
// 2nd service config without addresses // 2nd service config without addresses
ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class); verify(mockLoadBalancer).acceptResolvedAddresses(any(ResolvedAddresses.class));
verify(mockLoadBalancer, never()).handleResolvedAddresses(any(ResolvedAddresses.class));
verify(mockLoadBalancer).handleNameResolutionError(statusCaptor.capture()); // A resolution retry has been scheduled
assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.UNAVAILABLE); assertEquals(1, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER));
assertThat(statusCaptor.getValue().getDescription())
.contains("NameResolver returned no usable address.");
assertThat(channel.getState(true)).isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
assertWithMessage("Empty address should schedule NameResolver retry")
.that(getNameResolverRefresh())
.isNotNull();
} }
@Test @Test
@ -302,7 +297,6 @@ public class ServiceConfigErrorHandlingTest {
.setServers(Collections.emptyList()) .setServers(Collections.emptyList())
.build(); .build();
channelBuilder.nameResolverFactory(nameResolverFactory); channelBuilder.nameResolverFactory(nameResolverFactory);
when(mockLoadBalancer.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
Map<String, Object> rawServiceConfig = Map<String, Object> rawServiceConfig =
parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"val\"}}]}"); parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"val\"}}]}");
@ -312,7 +306,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).isEmpty(); assertThat(resolvedAddresses.getAddresses()).isEmpty();
@ -338,7 +332,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo"); assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo");
@ -360,7 +354,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isNull(); assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isNull();
@ -386,7 +380,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo"); assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo");
@ -431,7 +425,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
@ -462,7 +456,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config"); assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config");
@ -477,7 +471,7 @@ public class ServiceConfigErrorHandlingTest {
nextLbPolicyConfigError.set(Status.UNKNOWN); nextLbPolicyConfigError.set(Status.UNKNOWN);
nameResolverFactory.allResolved(); nameResolverFactory.allResolved();
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses newResolvedAddress = resultCaptor.getValue(); ResolvedAddresses newResolvedAddress = resultCaptor.getValue();
// should use previous service config because new service config is invalid. // should use previous service config because new service config is invalid.
assertThat(newResolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config"); assertThat(newResolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config");
@ -510,7 +504,7 @@ public class ServiceConfigErrorHandlingTest {
ArgumentCaptor<ResolvedAddresses> resultCaptor = ArgumentCaptor<ResolvedAddresses> resultCaptor =
ArgumentCaptor.forClass(ResolvedAddresses.class); ArgumentCaptor.forClass(ResolvedAddresses.class);
verify(mockLoadBalancer).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses resolvedAddresses = resultCaptor.getValue(); ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup); assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
// should use previous service config because new resolution result is no config. // should use previous service config because new resolution result is no config.
@ -522,7 +516,7 @@ public class ServiceConfigErrorHandlingTest {
nameResolverFactory.nextRawServiceConfig.set(null); nameResolverFactory.nextRawServiceConfig.set(null);
nameResolverFactory.allResolved(); nameResolverFactory.allResolved();
verify(mockLoadBalancer, times(2)).handleResolvedAddresses(resultCaptor.capture()); verify(mockLoadBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
ResolvedAddresses newResolvedAddress = resultCaptor.getValue(); ResolvedAddresses newResolvedAddress = resultCaptor.getValue();
assertThat(newResolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo("mate"); assertThat(newResolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo("mate");
assertThat(newResolvedAddress.getAttributes().get(InternalConfigSelector.KEY)) assertThat(newResolvedAddress.getAttributes().get(InternalConfigSelector.KEY))
@ -658,6 +652,8 @@ public class ServiceConfigErrorHandlingTest {
private static class FakeLoadBalancer extends LoadBalancer { private static class FakeLoadBalancer extends LoadBalancer {
private boolean acceptAddresses = true;
@Nullable @Nullable
private Helper helper; private Helper helper;
@ -665,6 +661,15 @@ public class ServiceConfigErrorHandlingTest {
this.helper = helper; this.helper = helper;
} }
@Override
public boolean acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
return acceptAddresses;
}
public void setAcceptAddresses(boolean acceptAddresses) {
this.acceptAddresses = acceptAddresses;
}
@Override @Override
public void handleNameResolutionError(final Status error) { public void handleNameResolutionError(final Status error) {
helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE,

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

@ -568,7 +568,7 @@ public class CachingRlsLbClientTest {
LoadBalancer loadBalancer = new LoadBalancer() { LoadBalancer loadBalancer = new LoadBalancer() {
@Override @Override
public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) { public boolean 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(
@ -590,6 +590,8 @@ public class CachingRlsLbClientTest {
} }
}); });
} }
return true;
} }
@Override @Override