xds: makes getAuthority() static

Author: AgraVator

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

@@ -34,15 +34,13 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 
 /**
@@ -145,15 +143,7 @@ void reportCallbackMetrics(BatchRecorder recorder, XdsClient xdsClient) {
       Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType =
           getResourceMetadataCompleted.get(10, TimeUnit.SECONDS);
 
-      List<String> resourceNames = metadataByType.values()
-          .stream()
-          .flatMap(innerMap -> innerMap.keySet().stream())
-          .collect(Collectors.toList());
-
-      Map<String, String> resourceNameToAuthority =
-          xdsClient.getResourceNameToAuthorityMap(resourceNames);
-
-      computeAndReportResourceCounts(metadataByType, resourceNameToAuthority, callback);
+      computeAndReportResourceCounts(metadataByType, callback);
 
       // Normally this shouldn't take long, but adding a timeout to avoid indefinite blocking
       Void unused = reportServerConnectionsCompleted.get(5, TimeUnit.SECONDS);
@@ -167,7 +157,6 @@ void reportCallbackMetrics(BatchRecorder recorder, XdsClient xdsClient) {
 
   private void computeAndReportResourceCounts(
       Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType,
-      Map<String, String> resourceNameToAuthority,
       MetricReporterCallback callback) {
     for (Map.Entry<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByTypeEntry :
         metadataByType.entrySet()) {
@@ -178,7 +167,7 @@ private void computeAndReportResourceCounts(
       for (Map.Entry<String, ResourceMetadata> resourceEntry : resources.entrySet()) {
         String resourceName = resourceEntry.getKey();
         ResourceMetadata metadata = resourceEntry.getValue();
-        String authority = resourceNameToAuthority.getOrDefault(resourceName, "");
+        String authority = XdsClient.getAuthorityFromResourceName(resourceName);
         String cacheState = cacheStateFromResourceStatus(metadata.getStatus(), metadata.isCached());
         resourceCountsByAuthorityAndState
             .computeIfAbsent(authority, k -> new HashMap<>())
@@ -230,7 +219,7 @@ static final class MetricReporterCallback implements ServerConnectionCallback {
     void reportResourceCountGauge(String authority, long resourceCount, String cacheState,
         String resourceType) {
       recorder.recordLongGauge(RESOURCES_GAUGE, resourceCount,
-          Arrays.asList(target, authority == null || authority.isEmpty() ? "#old" : authority,
+          Arrays.asList(target, authority == null ? "#old" : authority,
           cacheState, resourceType), Collections.emptyList());
     }
 

xds/src/main/java/io/grpc/xds/client/XdsClient.java

@@ -379,10 +379,20 @@ public Map<Bootstrapper.ServerInfo, LoadReportClient> getServerLrsClientMap() {
   }
 
   /**
-   * Returns a map of resource names to the authority.
+   * Returns the authority from the resource name.
    */
-  public Map<String, String> getResourceNameToAuthorityMap(List<String> resourceNames) {
-    throw new UnsupportedOperationException();
+  public static String getAuthorityFromResourceName(String resourceNames) {
+    String authority;
+    if (resourceNames.startsWith(XDSTP_SCHEME)) {
+      URI uri = URI.create(resourceNames);
+      authority = uri.getAuthority();
+      if (authority == null) {
+        authority = "";
+      }
+    } else {
+      authority = null;
+    }
+    return authority;
   }
 
   /** Callback used to report a gauge metric value for server connections. */

xds/src/main/java/io/grpc/xds/client/XdsClientImpl.java

@@ -18,7 +18,6 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
-import static io.grpc.xds.client.Bootstrapper.XDSTP_SCHEME;
 import static io.grpc.xds.client.XdsResourceType.ParsedResource;
 import static io.grpc.xds.client.XdsResourceType.ValidatedResourceUpdate;
 
@@ -43,7 +42,6 @@
 import io.grpc.xds.client.XdsClient.ResourceStore;
 import io.grpc.xds.client.XdsLogger.XdsLogLevel;
 import java.io.IOException;
-import java.net.URI;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -57,7 +55,6 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 
@@ -531,32 +528,6 @@ public Map<ServerInfo, LoadReportClient> getServerLrsClientMap() {
     return ImmutableMap.copyOf(serverLrsClientMap);
   }
 
-  private String getAuthority(String resource) {
-    String authority;
-    if (resource.startsWith(XDSTP_SCHEME)) {
-      URI uri = URI.create(resource);
-      authority = uri.getAuthority();
-      if (authority == null) {
-        authority = "";
-      }
-    } else {
-      authority = null;
-    }
-
-    return authority;
-  }
-
-  @Override
-  public Map<String, String> getResourceNameToAuthorityMap(List<String> resourceNames) {
-    if (resourceNames == null || resourceNames.isEmpty()) {
-      return Collections.emptyMap();
-    }
-    return resourceNames.stream()
-        .collect(Collectors.toMap(
-            Function.identity(),
-            this::getAuthority));
-  }
-
   @Nullable
   private ImmutableList<ServerInfo> getServerInfos(String authority) {
     if (authority != null) {
@@ -710,7 +681,7 @@ private final class ResourceSubscriber<T extends ResourceUpdate> {
       syncContext.throwIfNotInThisSynchronizationContext();
       this.type = type;
       this.resource = resource;
-      this.authority = getAuthority(resource);
+      this.authority = getAuthorityFromResourceName(resource);
       if (getServerInfos(authority) == null) {
         this.errorDescription = "Wrong configuration: xds server does not exist for resource "
             + resource;

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

@@ -19,7 +19,6 @@
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.AdditionalAnswers.delegatesTo;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.inOrder;
@@ -233,43 +232,36 @@ public void metricReporterCallback() {
   @Test
   public void reportCallbackMetrics_computeAndReportResourceCounts() {
     Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType = new HashMap<>();
-    Map<String, String> resourceNameByAuthority = new HashMap<>();
     XdsResourceType<?> listenerResource = XdsListenerResource.getInstance();
     XdsResourceType<?> routeConfigResource = XdsRouteConfigureResource.getInstance();
     XdsResourceType<?> clusterResource = XdsClusterResource.getInstance();
 
     Any rawListener =
-        Any.pack(Listener.newBuilder().setName("listener.googleapis.com").build());
+            Any.pack(Listener.newBuilder().setName("listener.googleapis.com").build());
     long nanosLastUpdate = 1577923199_606042047L;
 
     Map<String, ResourceMetadata> ldsResourceMetadataMap = new HashMap<>();
-    ldsResourceMetadataMap.put("resource1",
-        ResourceMetadata.newResourceMetadataRequested());
-    resourceNameByAuthority.put("resource1", "authority1");
+    ldsResourceMetadataMap.put("xdstp://authority1",
+            ResourceMetadata.newResourceMetadataRequested());
     ResourceMetadata ackedLdsResource = ResourceMetadata.newResourceMetadataAcked(rawListener, "42",
-        nanosLastUpdate);
+            nanosLastUpdate);
     ldsResourceMetadataMap.put("resource2", ackedLdsResource);
-    resourceNameByAuthority.put("resource2", "authority2");
     ldsResourceMetadataMap.put("resource3",
-        ResourceMetadata.newResourceMetadataAcked(rawListener, "43", nanosLastUpdate));
-    resourceNameByAuthority.put("resource3", "authority2");
-    ldsResourceMetadataMap.put("resource4",
-        ResourceMetadata.newResourceMetadataNacked(ackedLdsResource, "44", nanosLastUpdate,
-            "nacked after previous ack", true));
-    resourceNameByAuthority.put("resource4", "authority4");
+            ResourceMetadata.newResourceMetadataAcked(rawListener, "43", nanosLastUpdate));
+    ldsResourceMetadataMap.put("xdstp:/need_this",
+            ResourceMetadata.newResourceMetadataNacked(ackedLdsResource, "44", nanosLastUpdate,
+                    "nacked after previous ack", true));
 
     Map<String, ResourceMetadata> rdsResourceMetadataMap = new HashMap<>();
     ResourceMetadata requestedRdsResourceMetadata = ResourceMetadata.newResourceMetadataRequested();
-    rdsResourceMetadataMap.put("resource5",
-        ResourceMetadata.newResourceMetadataNacked(requestedRdsResourceMetadata, "24",
-            nanosLastUpdate, "nacked after request", false));
-    resourceNameByAuthority.put("resource5", "authority5");
-    rdsResourceMetadataMap.put("resource6",
-        ResourceMetadata.newResourceMetadataDoesNotExist());
-    resourceNameByAuthority.put("resource6", "authority6");
+    rdsResourceMetadataMap.put("xdstp://authority5",
+            ResourceMetadata.newResourceMetadataNacked(requestedRdsResourceMetadata, "24",
+                    nanosLastUpdate, "nacked after request", false));
+    rdsResourceMetadataMap.put("xdstp://authority6",
+            ResourceMetadata.newResourceMetadataDoesNotExist());
 
     Map<String, ResourceMetadata> cdsResourceMetadataMap = new HashMap<>();
-    cdsResourceMetadataMap.put("resource7", ResourceMetadata.newResourceMetadataUnknown());
+    cdsResourceMetadataMap.put("xdstp://authority7", ResourceMetadata.newResourceMetadataUnknown());
 
     metadataByType.put(listenerResource, ldsResourceMetadataMap);
     metadataByType.put(routeConfigResource, rdsResourceMetadataMap);
@@ -278,15 +270,13 @@ public void reportCallbackMetrics_computeAndReportResourceCounts() {
     SettableFuture<Void> reportServerConnectionsCompleted = SettableFuture.create();
     reportServerConnectionsCompleted.set(null);
     when(mockXdsClient.reportServerConnections(any(MetricReporterCallback.class)))
-        .thenReturn(reportServerConnectionsCompleted);
+            .thenReturn(reportServerConnectionsCompleted);
 
     ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
-        getResourceMetadataCompleted = Futures.immediateFuture(metadataByType);
+            getResourceMetadataCompleted = Futures.immediateFuture(metadataByType);
     when(mockXdsClient.getSubscribedResourcesMetadataSnapshot())
-        .thenReturn(getResourceMetadataCompleted);
+            .thenReturn(getResourceMetadataCompleted);
 
-    when(mockXdsClient.getResourceNameToAuthorityMap(anyList()))
-            .thenReturn(resourceNameByAuthority);
 
     reporter.reportCallbackMetrics(mockBatchRecorder, mockXdsClient);
 
@@ -296,11 +286,11 @@ public void reportCallbackMetrics_computeAndReportResourceCounts() {
             "requested", listenerResource.typeUrl())), any());
     // LDS resources acked
     verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
-        eq(2L), eq(Arrays.asList(target, "authority2",
+        eq(2L), eq(Arrays.asList(target, "#old",
             "acked", listenerResource.typeUrl())), any());
     // LDS resource nacked but cached
     verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
-        eq(1L), eq(Arrays.asList(target, "authority4",
+        eq(1L), eq(Arrays.asList(target, "",
             "nacked_but_cached", listenerResource.typeUrl())), any());
 
     // RDS resource nacked
@@ -314,7 +304,7 @@ public void reportCallbackMetrics_computeAndReportResourceCounts() {
 
     // CDS resource unknown
     verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
-        eq(1L), eq(Arrays.asList(target, "#old",
+        eq(1L), eq(Arrays.asList(target, "authority7",
             "unknown", clusterResource.typeUrl())), any());
     verifyNoMoreInteractions(mockBatchRecorder);
   }