Implement GrpcCelEnvironment and MetadataHelper

Author: sergiitk

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2024 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.xds.internal;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.io.BaseEncoding;
+import io.grpc.Metadata;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nullable;
+
+
+public class MetadataHelper {
+  public static ImmutableMap<String, String> metadataToHeaders(Metadata metadata) {
+    return metadata.keys().stream().collect(ImmutableMap.toImmutableMap(
+        headerName -> headerName,
+        headerName -> Strings.nullToEmpty(deserializeHeader(metadata, headerName))));
+  }
+
+  @Nullable
+  public static String deserializeHeader(Metadata metadata, String headerName) {
+    if (headerName.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+      Metadata.Key<byte[]> key;
+      try {
+        key = Metadata.Key.of(headerName, Metadata.BINARY_BYTE_MARSHALLER);
+      } catch (IllegalArgumentException e) {
+        return null;
+      }
+      Iterable<byte[]> values = metadata.getAll(key);
+      if (values == null) {
+        return null;
+      }
+      List<String> encoded = new ArrayList<>();
+      for (byte[] v : values) {
+        encoded.add(BaseEncoding.base64().omitPadding().encode(v));
+      }
+      return String.join(",", encoded);
+    }
+    Metadata.Key<String> key;
+    try {
+      key = Metadata.Key.of(headerName, Metadata.ASCII_STRING_MARSHALLER);
+    } catch (IllegalArgumentException e) {
+      return null;
+    }
+    Iterable<String> values = metadata.getAll(key);
+    return values == null ? null : String.join(",", values);
+  }
+}

xds/src/main/java/io/grpc/xds/internal/matchers/CelMatcher.java

@@ -18,23 +18,18 @@
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
-import com.google.common.collect.ImmutableMap;
 import dev.cel.common.CelAbstractSyntaxTree;
 import dev.cel.runtime.CelEvaluationException;
-import dev.cel.runtime.CelRuntime;
-import dev.cel.runtime.CelRuntimeFactory;
 import java.util.function.Predicate;
 
 /** Unified Matcher API: xds.type.matcher.v3.CelMatcher. */
 public class CelMatcher implements Predicate<HttpMatchInput> {
-  private static final CelRuntime CEL_RUNTIME =
-      CelRuntimeFactory.standardCelRuntimeBuilder().build();
 
-  private final CelRuntime.Program program;
+  private final GrpcCelEnvironment program;
   private final String description;
 
   private CelMatcher(CelAbstractSyntaxTree ast, String description) throws CelEvaluationException {
-    this.program = CEL_RUNTIME.createProgram(checkNotNull(ast));
+    this.program = new GrpcCelEnvironment(checkNotNull(ast));
     this.description = description != null ? description : "";
   }
 
@@ -57,11 +52,6 @@ public boolean test(HttpMatchInput httpMatchInput) {
     //   return false;
     // }
     // TODO(sergiitk): [IMPL] convert headers to cel args
-    try {
-      return (boolean) program.eval(ImmutableMap.of("my_var", "Hello World"));
-    } catch (CelEvaluationException e) {
-      // TODO(sergiitk): [IMPL] log cel error?
-      return false;
-    }
+    return program.eval(httpMatchInput.serverCall(), httpMatchInput.headers());
   }
 }

xds/src/main/java/io/grpc/xds/internal/matchers/GrpcCelEnvironment.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2024 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.xds.internal.matchers;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableMap;
+import dev.cel.common.CelAbstractSyntaxTree;
+import dev.cel.common.CelOptions;
+import dev.cel.common.types.SimpleType;
+import dev.cel.runtime.CelEvaluationException;
+import dev.cel.runtime.CelRuntime;
+import dev.cel.runtime.CelRuntimeFactory;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.Status;
+import io.grpc.xds.internal.MetadataHelper;
+
+/** Unified Matcher API: xds.type.matcher.v3.CelMatcher. */
+public class GrpcCelEnvironment  {
+  private static final CelRuntime CEL_RUNTIME = CelRuntimeFactory
+      .standardCelRuntimeBuilder()
+      .setOptions(CelOptions.current().comprehensionMaxIterations(0).build())
+      .build();
+
+  private final CelRuntime.Program program;
+
+  GrpcCelEnvironment(CelAbstractSyntaxTree ast) throws CelEvaluationException {
+    if (ast.getResultType() != SimpleType.BOOL) {
+      throw new CelEvaluationException("Expected bool return type");
+    }
+    this.program = CEL_RUNTIME.createProgram(ast);
+  }
+
+  public boolean eval(ServerCall<?, ?> serverCall, Metadata metadata) {
+    ImmutableMap.Builder<String, Object> requestBuilder = ImmutableMap.<String, Object>builder()
+        .put("method", "POST")
+        .put("host", Strings.nullToEmpty(serverCall.getAuthority()))
+        .put("path", "/" + serverCall.getMethodDescriptor().getFullMethodName())
+        .put("headers", MetadataHelper.metadataToHeaders(metadata));
+    // TODO(sergiitk): handle other pseudo-headers
+    try {
+      return (boolean) program.eval(ImmutableMap.of("request", requestBuilder.build()));
+    } catch (CelEvaluationException e) {
+      throw Status.fromThrowable(e).asRuntimeException();
+    }
+  }
+}

xds/src/main/java/io/grpc/xds/internal/matchers/HttpMatchInput.java

@@ -19,10 +19,12 @@
 
 import com.google.auto.value.AutoValue;
 import io.grpc.Metadata;
+import io.grpc.ServerCall;
 
 @AutoValue
 public abstract class HttpMatchInput {
   public abstract Metadata headers();
+
   // TODO(sergiitk): [IMPL] consider
-  // public abstract ServerCall<?, ?> serverCall();
+  public abstract ServerCall<?, ?> serverCall();
 }

xds/src/test/java/io/grpc/xds/internal/matchers/CelMatcherTest.java

@@ -25,6 +25,11 @@
 import dev.cel.compiler.CelCompilerFactory;
 import dev.cel.runtime.CelEvaluationException;
 import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.NoopServerCall;
+import io.grpc.ServerCall;
+import io.grpc.StringMarshaller;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -35,9 +40,12 @@ public class CelMatcherTest {
   // Construct the compilation and runtime environments.
   // These instances are immutable and thus trivially thread-safe and amenable to caching.
   private static final CelCompiler CEL_COMPILER =
-      CelCompilerFactory.standardCelCompilerBuilder().addVar("my_var", SimpleType.STRING).build();
+      CelCompilerFactory.standardCelCompilerBuilder()
+          .addVar("request", SimpleType.ANY)
+          .setResultType(SimpleType.BOOL)
+          .build();
   private static final CelValidationResult celProg1 =
-      CEL_COMPILER.compile("type(my_var) == string");
+      CEL_COMPILER.compile("request.method == \"POST\"");
 
   CelAbstractSyntaxTree ast1;
   CelMatcher matcher1;
@@ -47,6 +55,22 @@ public class CelMatcherTest {
     public Metadata headers() {
       return new Metadata();
     }
+
+    @Override public ServerCall<?, ?> serverCall() {
+      final MethodDescriptor<String, String> method =
+          MethodDescriptor.<String, String>newBuilder()
+              .setType(MethodType.UNKNOWN)
+              .setFullMethodName("service/method")
+              .setRequestMarshaller(new StringMarshaller())
+              .setResponseMarshaller(new StringMarshaller())
+              .build();
+      return new NoopServerCall<String, String>() {
+        @Override
+        public MethodDescriptor<String, String> getMethodDescriptor() {
+          return method;
+        }
+      };
+    }
   };
 
   @Before