composite filter

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

@@ -35,10 +35,11 @@ private FilterRegistry() {}
   static synchronized FilterRegistry getDefaultRegistry() {
     if (instance == null) {
       instance = newRegistry().register(
-              new FaultFilter.Provider(),
-              new RouterFilter.Provider(),
-              new RbacFilter.Provider(),
-              new GcpAuthenticationFilter.Provider());
+          new FaultFilter.Provider(),
+          new RouterFilter.Provider(),
+          new RbacFilter.Provider(),
+          new GcpAuthenticationFilter.Provider(),
+          new CompositeFilter.Provider());
     }
     return instance;
   }
@@ -58,6 +59,13 @@ FilterRegistry register(Filter.Provider... filters) {
     return this;
   }
 
+  @VisibleForTesting
+  void deregister(Filter.Provider provider) {
+    for (String typeUrl : provider.typeUrls()) {
+      supportedFilters.remove(typeUrl);
+    }
+  }
+
   @Nullable
   Filter.Provider get(String typeUrl) {
     return supportedFilters.get(typeUrl);

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

@@ -65,21 +65,38 @@ abstract static class Route {
 
     abstract ImmutableMap<String, FilterConfig> filterConfigOverrides();
 
+    @Nullable
+    abstract ImmutableMap<String, com.google.protobuf.Struct> filterMetadata();
+
     static Route forAction(RouteMatch routeMatch, RouteAction routeAction,
         Map<String, FilterConfig> filterConfigOverrides) {
-      return create(routeMatch, routeAction, filterConfigOverrides);
+      return create(routeMatch, routeAction, filterConfigOverrides, null);
+    }
+
+    static Route forAction(RouteMatch routeMatch, RouteAction routeAction,
+        Map<String, FilterConfig> filterConfigOverrides,
+        @Nullable Map<String, com.google.protobuf.Struct> filterMetadata) {
+      return create(routeMatch, routeAction, filterConfigOverrides, filterMetadata);
     }
 
     static Route forNonForwardingAction(RouteMatch routeMatch,
         Map<String, FilterConfig> filterConfigOverrides) {
-      return create(routeMatch, null, filterConfigOverrides);
+      return create(routeMatch, null, filterConfigOverrides, null);
+    }
+
+    static Route forNonForwardingAction(RouteMatch routeMatch,
+        Map<String, FilterConfig> filterConfigOverrides,
+        @Nullable Map<String, com.google.protobuf.Struct> filterMetadata) {
+      return create(routeMatch, null, filterConfigOverrides, filterMetadata);
     }
 
     private static Route create(
         RouteMatch routeMatch, @Nullable RouteAction routeAction,
-        Map<String, FilterConfig> filterConfigOverrides) {
+        Map<String, FilterConfig> filterConfigOverrides,
+        @Nullable Map<String, com.google.protobuf.Struct> filterMetadata) {
       return new AutoValue_VirtualHost_Route(
-          routeMatch, routeAction, ImmutableMap.copyOf(filterConfigOverrides));
+          routeMatch, routeAction, ImmutableMap.copyOf(filterConfigOverrides),
+          filterMetadata == null ? null : ImmutableMap.copyOf(filterMetadata));
     }
 
     @AutoValue

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

@@ -16,13 +16,15 @@
 
 package io.grpc.xds;
 
+import com.google.protobuf.Struct;
 import io.grpc.Attributes;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.Grpc;
 import io.grpc.NameResolver;
 import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
 import io.grpc.xds.client.Locality;
 import io.grpc.xds.client.XdsClient;
+import java.util.Map;
 
 /**
  * Attributes used for xDS implementation.
@@ -100,5 +102,18 @@ final class XdsAttributes {
   static final Attributes.Key<Long> ATTR_DRAIN_GRACE_NANOS =
       Attributes.Key.create("io.grpc.xds.XdsAttributes.drainGraceTime");
 
+  /**
+   * Attribute key for xDS route metadata used in filter matching.
+   */
+  @NameResolver.ResolutionResultAttr
+  public static final Attributes.Key<Map<String, Struct>> ATTR_FILTER_METADATA = Attributes.Key
+          .create("io.grpc.xds.XdsAttributes.filterMetadata");
+
+  /**
+   * CallOptions key for xDS route metadata used in filter matching.
+   */
+  public static final io.grpc.CallOptions.Key<Map<String, Struct>> CALL_OPTIONS_FILTER_METADATA =
+      io.grpc.CallOptions.Key.create("io.grpc.xds.XdsAttributes.filterMetadata");
+
   private XdsAttributes() {}
 }

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

@@ -230,7 +230,7 @@ static FilterChain parseFilterChain(
     // FilterChain contains L4 filters, so we ensure it contains only HCM.
     if (proto.getFiltersCount() != 1) {
       throw new ResourceInvalidException("FilterChain " + filterChainName
-          + " should contain exact one HttpConnectionManager filter");
+          + " should contain exactly one HttpConnectionManager filter");
     }
     io.envoyproxy.envoy.config.listener.v3.Filter l4Filter = proto.getFiltersList().get(0);
     if (!l4Filter.hasTypedConfig()) {

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

@@ -716,6 +716,7 @@ public void onUpdate(StatusOr<XdsConfig> updateOrStatus) {
       }
 
       VirtualHost virtualHost = update.getVirtualHost();
+      // filters and there configurations
       ImmutableList<NamedFilterConfig> filterConfigs = httpConnectionManager.httpFilterConfigs();
       long streamDurationNano = httpConnectionManager.httpMaxStreamDurationNano();
 

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

@@ -29,6 +29,7 @@
 import com.google.protobuf.Duration;
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.google.protobuf.Message;
+import com.google.protobuf.Struct;
 import com.google.protobuf.util.Durations;
 import com.google.re2j.Pattern;
 import com.google.re2j.PatternSyntaxException;
@@ -289,6 +290,11 @@ static StructOrError<Route> parseRoute(
     }
     Map<String, FilterConfig> overrideConfigs = overrideConfigsOrError.getStruct();
 
+    Map<String, Struct> filterMetadata = null;
+    if (proto.hasMetadata()) {
+      filterMetadata = proto.getMetadata().getFilterMetadataMap();
+    }
+
     switch (proto.getActionCase()) {
       case ROUTE:
         StructOrError<RouteAction> routeAction =
@@ -303,10 +309,11 @@ static StructOrError<Route> parseRoute(
                   + routeAction.getErrorDetail());
         }
         return StructOrError.fromStruct(
-            Route.forAction(routeMatch.getStruct(), routeAction.getStruct(), overrideConfigs));
+            Route.forAction(routeMatch.getStruct(), routeAction.getStruct(), overrideConfigs,
+                filterMetadata));
       case NON_FORWARDING_ACTION:
         return StructOrError.fromStruct(
-            Route.forNonForwardingAction(routeMatch.getStruct(), overrideConfigs));
+            Route.forNonForwardingAction(routeMatch.getStruct(), overrideConfigs, filterMetadata));
       case REDIRECT:
       case DIRECT_RESPONSE:
       case FILTER_ACTION:

xds/src/main/java/io/grpc/xds/internal/MatcherParser.java

@@ -91,10 +91,36 @@ public static Matchers.StringMatcher parseStringMatcher(
                 Pattern.compile(proto.getSafeRegex().getRegex()));
       case CONTAINS:
         return Matchers.StringMatcher.forContains(proto.getContains());
+      case CUSTOM:
+        throw new IllegalArgumentException("custom string matcher is not supported");
       case MATCHPATTERN_NOT_SET:
       default:
         throw new IllegalArgumentException(
                 "Unknown StringMatcher match pattern: " + proto.getMatchPatternCase());
     }
   }
+
+  /** Translate StringMatcher xDS proto to internal StringMatcher. */
+  public static Matchers.StringMatcher parseStringMatcher(
+      com.github.xds.type.matcher.v3.StringMatcher proto) {
+    switch (proto.getMatchPatternCase()) {
+      case EXACT:
+        return Matchers.StringMatcher.forExact(proto.getExact(), proto.getIgnoreCase());
+      case PREFIX:
+        return Matchers.StringMatcher.forPrefix(proto.getPrefix(), proto.getIgnoreCase());
+      case SUFFIX:
+        return Matchers.StringMatcher.forSuffix(proto.getSuffix(), proto.getIgnoreCase());
+      case SAFE_REGEX:
+        return Matchers.StringMatcher.forSafeRegEx(
+            Pattern.compile(proto.getSafeRegex().getRegex()));
+      case CONTAINS:
+        return Matchers.StringMatcher.forContains(proto.getContains());
+      case CUSTOM:
+        throw new IllegalArgumentException("custom string matcher is not supported");
+      case MATCHPATTERN_NOT_SET:
+      default:
+        throw new IllegalArgumentException(
+            "Unknown StringMatcher match pattern: " + proto.getMatchPatternCase());
+    }
+  }
 }