Feat: recursively propagate childChannelConfigurator in OOB and xDS control plane channels

Author: AgraVator

core/src/main/java/io/grpc/internal/ManagedChannelImpl.java

@@ -1501,6 +1501,7 @@ protected ManagedChannelBuilder<?> delegate() {
       // Note that we follow the global configurator pattern and try to fuse the configurations as
       // soon as the builder gets created
       channelConfigurator.configureChannelBuilder(builder);
+      builder.childChannelConfigurator(channelConfigurator);
 
       return builder
           // TODO(zdapeng): executors should not outlive the parent channel.

core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java

@@ -531,6 +531,48 @@ protected int priority() {
     assertSame(configurator, actualArgs.get().getChildChannelConfigurator());
   }
 
+  @Test
+  public void childChannelConfigurator_passedToResolvingOobChannelNameResolverArgs() {
+    ChannelConfigurator configurator = builder -> { };
+    channelBuilder.childChannelConfigurator(configurator);
+    AtomicReference<NameResolver.Args> oobArgs = new AtomicReference<>();
+    channelBuilder.nameResolverRegistry.register(new NameResolverProvider() {
+      @Override
+      public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        if ("oobauthority".equals(targetUri.getAuthority())
+            || "oobauthority".equals(targetUri.getPath())
+            || targetUri.toString().contains("oobauthority")) {
+          oobArgs.set(args);
+        }
+        NameResolver resolver = mock(NameResolver.class);
+        when(resolver.getServiceAuthority()).thenReturn(
+            targetUri.getAuthority() != null ? targetUri.getAuthority() : targetUri.getPath());
+        return resolver;
+      }
+
+      @Override
+      public String getDefaultScheme() {
+        return expectedUri.getScheme();
+      }
+
+      @Override
+      protected boolean isAvailable() {
+        return true;
+      }
+
+      @Override
+      protected int priority() {
+        return 10;
+      }
+    });
+    createChannel();
+    ManagedChannel oob = helper.createResolvingOobChannelBuilder("oobauthority").build();
+    oob.getState(true);
+    assertNotNull(oobArgs.get());
+    assertSame(configurator, oobArgs.get().getChildChannelConfigurator());
+    oob.shutdownNow();
+  }
+
   @Test
   public void startCallBeforeNameResolution() throws Exception {
     FakeNameResolverFactory nameResolverFactory =

xds/src/main/java/io/grpc/xds/GrpcXdsTransportFactory.java

@@ -120,6 +120,7 @@ public GrpcXdsTransport(Bootstrapper.ServerInfo serverInfo,
           .keepAliveTime(5, TimeUnit.MINUTES);
       if (channelConfigurator != null) {
         channelConfigurator.configureChannelBuilder(channelBuilder);
+        channelBuilder.childChannelConfigurator(channelConfigurator);
       }
       this.channel = channelBuilder.build();
       this.callCredentials = callCredentials;

xds/src/test/java/io/grpc/xds/GrpcXdsTransportFactoryTest.java

@@ -17,8 +17,11 @@
 package io.grpc.xds;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import com.google.common.util.concurrent.SettableFuture;
 import io.envoyproxy.envoy.service.discovery.v3.AggregatedDiscoveryServiceGrpc;
@@ -35,6 +38,9 @@
 import io.grpc.InsecureServerCredentials;
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.MethodDescriptor;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
 import io.grpc.NoopClientCall;
 import io.grpc.Server;
 import io.grpc.Status;
@@ -43,9 +49,11 @@
 import io.grpc.testing.TestMethodDescriptors;
 import io.grpc.xds.client.Bootstrapper;
 import io.grpc.xds.client.XdsTransportFactory;
+import java.net.URI;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -280,6 +288,48 @@ public void configureChannelBuilder(ManagedChannelBuilder<?> builder) {
     transport.shutdown();
   }
 
+  @Test
+  public void useChannelConfigurator_setsChildChannelConfigurator() {
+    final AtomicReference<NameResolver.Args> capturedArgs = new AtomicReference<>();
+    NameResolverProvider testProvider = new NameResolverProvider() {
+      @Override
+      public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        capturedArgs.set(args);
+        NameResolver resolver = mock(NameResolver.class);
+        when(resolver.getServiceAuthority()).thenReturn("localhost:8080");
+        return resolver;
+      }
+
+      @Override
+      public String getDefaultScheme() {
+        return "test-xds-transport";
+      }
+
+      @Override
+      protected boolean isAvailable() {
+        return true;
+      }
+
+      @Override
+      protected int priority() {
+        return 10;
+      }
+    };
+    NameResolverRegistry.getDefaultRegistry().register(testProvider);
+    try {
+      ChannelConfigurator configurer = builder -> { };
+      GrpcXdsTransportFactory factory = new GrpcXdsTransportFactory(null, configurer);
+      XdsTransportFactory.XdsTransport transport = factory.create(
+          Bootstrapper.ServerInfo.create(
+              "test-xds-transport://localhost:8080", InsecureChannelCredentials.create()));
+      assertNotNull(capturedArgs.get());
+      assertSame(configurer, capturedArgs.get().getChildChannelConfigurator());
+      transport.shutdown();
+    } finally {
+      NameResolverRegistry.getDefaultRegistry().deregister(testProvider);
+    }
+  }
+
   @Test
   public void useChannelConfigurator_throwsException_propagates() {
     final RuntimeException testException = new RuntimeException("test exception");