grpc 1.34.0 → 1.42.0

data/src/core/lib/iomgr/udp_server.h

@@ -1,104 +0,0 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_UDP_SERVER_H
-#define GRPC_CORE_LIB_IOMGR_UDP_SERVER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <vector>
-
-#include "src/core/lib/iomgr/endpoint.h"
-#include "src/core/lib/iomgr/ev_posix.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-
-/* Forward decl of struct grpc_server */
-/* This is not typedef'ed to avoid a typedef-redefinition error */
-struct grpc_server;
-
-/* Forward decl of grpc_udp_server */
-typedef struct grpc_udp_server grpc_udp_server;
-
-/* An interface associated with a socket. udp server delivers I/O event on that
- * socket to the subclass of this interface which is created through
- * GrpcUdpHandlerFactory.
- * Its implementation should do the real IO work, e.g. read packet and write. */
-class GrpcUdpHandler {
- public:
-  GrpcUdpHandler(grpc_fd* /* emfd */, void* /* user_data */) {}
-  virtual ~GrpcUdpHandler() {}
-
-  // Interfaces to be implemented by subclasses to do the actual setup/tear down
-  // or I/O.
-
-  // Called when data is available to read from the socket. Returns true if
-  // there is more data to read after this call.
-  virtual bool Read() = 0;
-  // Called when socket becomes write unblocked. The given closure should be
-  // scheduled when the socket becomes blocked next time.
-  virtual void OnCanWrite(void* user_data,
-                          grpc_closure* notify_on_write_closure) = 0;
-  // Called before the gRPC FD is orphaned. Notify udp server to continue
-  // orphaning fd by scheduling the given closure, afterwards the associated fd
-  // will be closed.
-  virtual void OnFdAboutToOrphan(grpc_closure* orphan_fd_closure,
-                                 void* user_data) = 0;
-};
-
-class GrpcUdpHandlerFactory {
- public:
-  virtual ~GrpcUdpHandlerFactory() {}
-  /* Called when start to listen on a socket.
-   * Return an instance of the implementation of GrpcUdpHandler interface which
-   * will process I/O events for this socket from now on. */
-  virtual GrpcUdpHandler* CreateUdpHandler(grpc_fd* emfd, void* user_data) = 0;
-  virtual void DestroyUdpHandler(GrpcUdpHandler* handler) = 0;
-};
-
-/* Create a server, initially not bound to any ports */
-grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args);
-
-/* Start listening to bound ports. user_data is passed to callbacks. */
-void grpc_udp_server_start(grpc_udp_server* udp_server,
-                           const std::vector<grpc_pollset*>* pollsets,
-                           void* user_data);
-
-int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
-
-/* Add a port to the server, returning port number on success, or negative
-   on failure.
-
-   Create |num_listeners| sockets for given address to listen on using
-   SO_REUSEPORT if supported.
-
-   The :: and 0.0.0.0 wildcard addresses are treated identically, accepting
-   both IPv4 and IPv6 connections, but :: is the preferred style. This usually
-   creates |num_listeners| sockets, but possibly 2 * |num_listeners| on systems
-   which support IPv6, but not dualstack sockets. */
-
-/* TODO(ctiller): deprecate this, and make grpc_udp_server_add_ports to handle
-                  all of the multiple socket port matching logic in one place */
-int grpc_udp_server_add_port(grpc_udp_server* s,
-                             const grpc_resolved_address* addr,
-                             int rcv_buf_size, int snd_buf_size,
-                             GrpcUdpHandlerFactory* handler_factory,
-                             size_t num_listeners);
-
-void grpc_udp_server_destroy(grpc_udp_server* server, grpc_closure* on_done);
-
-#endif /* GRPC_CORE_LIB_IOMGR_UDP_SERVER_H */

data/src/core/lib/security/authorization/authorization_engine.cc

@@ -1,177 +0,0 @@
-// Copyright 2020 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.
-
-#include <grpc/support/port_platform.h>
-
-#include "absl/memory/memory.h"
-
-#include "src/core/lib/security/authorization/authorization_engine.h"
-
-namespace grpc_core {
-
-namespace {
-
-// Symbols for traversing Envoy Attributes
-constexpr char kUrlPath[] = "url_path";
-constexpr char kHost[] = "host";
-constexpr char kMethod[] = "method";
-constexpr char kHeaders[] = "headers";
-constexpr char kSourceAddress[] = "source_address";
-constexpr char kSourcePort[] = "source_port";
-constexpr char kDestinationAddress[] = "destination_address";
-constexpr char kDestinationPort[] = "destination_port";
-constexpr char kSpiffeId[] = "spiffe_id";
-constexpr char kCertServerName[] = "cert_server_name";
-
-}  // namespace
-
-std::unique_ptr<AuthorizationEngine>
-AuthorizationEngine::CreateAuthorizationEngine(
-    const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies) {
-  if (rbac_policies.empty() || rbac_policies.size() > 2) {
-    gpr_log(GPR_ERROR,
-            "Invalid rbac policies vector. Must contain either one or two rbac "
-            "policies.");
-    return nullptr;
-  } else if (rbac_policies.size() == 2 &&
-             (envoy_config_rbac_v3_RBAC_action(rbac_policies[0]) != kDeny ||
-              envoy_config_rbac_v3_RBAC_action(rbac_policies[1]) != kAllow)) {
-    gpr_log(GPR_ERROR,
-            "Invalid rbac policies vector. Must contain one deny \
-                         policy and one allow policy, in that order.");
-    return nullptr;
-  } else {
-    return absl::make_unique<AuthorizationEngine>(rbac_policies);
-  }
-}
-
-AuthorizationEngine::AuthorizationEngine(
-    const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies) {
-  for (const auto& rbac_policy : rbac_policies) {
-    // Extract array of policies and store their condition fields in either
-    // allow_if_matched_ or deny_if_matched_, depending on the policy action.
-    upb::Arena temp_arena;
-    size_t policy_num = UPB_MAP_BEGIN;
-    const envoy_config_rbac_v3_RBAC_PoliciesEntry* policy_entry;
-    while ((policy_entry = envoy_config_rbac_v3_RBAC_policies_next(
-                rbac_policy, &policy_num)) != nullptr) {
-      const upb_strview policy_name_strview =
-          envoy_config_rbac_v3_RBAC_PoliciesEntry_key(policy_entry);
-      const std::string policy_name(policy_name_strview.data,
-                                    policy_name_strview.size);
-      const envoy_config_rbac_v3_Policy* policy =
-          envoy_config_rbac_v3_RBAC_PoliciesEntry_value(policy_entry);
-      const google_api_expr_v1alpha1_Expr* condition =
-          envoy_config_rbac_v3_Policy_condition(policy);
-      // Parse condition to make a pointer tied to the lifetime of arena_.
-      size_t serial_len;
-      const char* serialized = google_api_expr_v1alpha1_Expr_serialize(
-          condition, temp_arena.ptr(), &serial_len);
-      const google_api_expr_v1alpha1_Expr* parsed_condition =
-          google_api_expr_v1alpha1_Expr_parse(serialized, serial_len,
-                                              arena_.ptr());
-      if (envoy_config_rbac_v3_RBAC_action(rbac_policy) == kAllow) {
-        allow_if_matched_.insert(std::make_pair(policy_name, parsed_condition));
-      } else {
-        deny_if_matched_.insert(std::make_pair(policy_name, parsed_condition));
-      }
-    }
-  }
-}
-
-std::unique_ptr<mock_cel::Activation> AuthorizationEngine::CreateActivation(
-    const EvaluateArgs& args) {
-  std::unique_ptr<mock_cel::Activation> activation;
-  for (const auto& elem : envoy_attributes_) {
-    if (elem == kUrlPath) {
-      absl::string_view url_path(args.GetPath());
-      if (!url_path.empty()) {
-        activation->InsertValue(kUrlPath,
-                                mock_cel::CelValue::CreateStringView(url_path));
-      }
-    } else if (elem == kHost) {
-      absl::string_view host(args.GetHost());
-      if (!host.empty()) {
-        activation->InsertValue(kHost,
-                                mock_cel::CelValue::CreateStringView(host));
-      }
-    } else if (elem == kMethod) {
-      absl::string_view method(args.GetMethod());
-      if (!method.empty()) {
-        activation->InsertValue(kMethod,
-                                mock_cel::CelValue::CreateStringView(method));
-      }
-    } else if (elem == kHeaders) {
-      std::multimap<absl::string_view, absl::string_view> headers =
-          args.GetHeaders();
-      std::vector<std::pair<mock_cel::CelValue, mock_cel::CelValue>>
-          header_items;
-      for (const auto& header_key : header_keys_) {
-        auto header_item = headers.find(header_key);
-        if (header_item != headers.end()) {
-          header_items.push_back(
-              std::pair<mock_cel::CelValue, mock_cel::CelValue>(
-                  mock_cel::CelValue::CreateStringView(header_key),
-                  mock_cel::CelValue::CreateStringView(header_item->second)));
-        }
-      }
-      headers_ = mock_cel::ContainerBackedMapImpl::Create(
-          absl::Span<std::pair<mock_cel::CelValue, mock_cel::CelValue>>(
-              header_items));
-      activation->InsertValue(kHeaders,
-                              mock_cel::CelValue::CreateMap(headers_.get()));
-    } else if (elem == kSourceAddress) {
-      absl::string_view source_address(args.GetPeerAddress());
-      if (!source_address.empty()) {
-        activation->InsertValue(
-            kSourceAddress,
-            mock_cel::CelValue::CreateStringView(source_address));
-      }
-    } else if (elem == kSourcePort) {
-      activation->InsertValue(
-          kSourcePort, mock_cel::CelValue::CreateInt64(args.GetPeerPort()));
-    } else if (elem == kDestinationAddress) {
-      absl::string_view destination_address(args.GetLocalAddress());
-      if (!destination_address.empty()) {
-        activation->InsertValue(
-            kDestinationAddress,
-            mock_cel::CelValue::CreateStringView(destination_address));
-      }
-    } else if (elem == kDestinationPort) {
-      activation->InsertValue(kDestinationPort, mock_cel::CelValue::CreateInt64(
-                                                    args.GetLocalPort()));
-    } else if (elem == kSpiffeId) {
-      absl::string_view spiffe_id(args.GetSpiffeId());
-      if (!spiffe_id.empty()) {
-        activation->InsertValue(
-            kSpiffeId, mock_cel::CelValue::CreateStringView(spiffe_id));
-      }
-    } else if (elem == kCertServerName) {
-      absl::string_view cert_server_name(args.GetCertServerName());
-      if (!cert_server_name.empty()) {
-        activation->InsertValue(
-            kCertServerName,
-            mock_cel::CelValue::CreateStringView(cert_server_name));
-      }
-    } else {
-      gpr_log(GPR_ERROR,
-              "Error: Authorization engine does not support evaluating "
-              "attribute %s.",
-              elem.c_str());
-    }
-  }
-  return activation;
-}
-
-}  // namespace grpc_core

data/src/core/lib/security/authorization/mock_cel/activation.h

@@ -1,57 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H
-
-#include <grpc/support/port_platform.h>
-
-#include "absl/strings/string_view.h"
-
-#include "src/core/lib/security/authorization/mock_cel/cel_value.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// Base class for an activation. This is a temporary stub implementation of CEL
-// APIs. Once gRPC imports the CEL library, this class will be removed.
-class BaseActivation {
- public:
-  BaseActivation() = default;
-
-  // Non-copyable/non-assignable
-  BaseActivation(const BaseActivation&) = delete;
-  BaseActivation& operator=(const BaseActivation&) = delete;
-};
-
-// Instance of Activation class is used by evaluator.
-// It provides binding between references used in expressions
-// and actual values. This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this class will be removed.
-class Activation : public BaseActivation {
- public:
-  Activation() = default;
-
-  // Non-copyable/non-assignable
-  Activation(const Activation&) = delete;
-  Activation& operator=(const Activation&) = delete;
-
-  // Insert value into Activation.
-  void InsertValue(absl::string_view name, const CelValue& value) {}
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H

data/src/core/lib/security/authorization/mock_cel/cel_expr_builder_factory.h

@@ -1,44 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-
-#include "absl/memory/memory.h"
-
-#include "src/core/lib/security/authorization/mock_cel/flat_expr_builder.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-struct InterpreterOptions {
-  bool short_circuiting = true;
-};
-
-inline std::unique_ptr<CelExpressionBuilder> CreateCelExpressionBuilder(
-    const InterpreterOptions& options) {
-  return absl::make_unique<FlatExprBuilder>();
-}
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H

data/src/core/lib/security/authorization/mock_cel/cel_expression.h

@@ -1,69 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-#include <vector>
-
-#include "absl/status/statusor.h"
-
-#include "google/api/expr/v1alpha1/syntax.upb.h"
-#include "src/core/lib/security/authorization/mock_cel/activation.h"
-#include "src/core/lib/security/authorization/mock_cel/cel_value.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-// Base interface for expression evaluating objects.
-class CelExpression {
- public:
-  virtual ~CelExpression() = default;
-
-  // Evaluates expression and returns value.
-  // activation contains bindings from parameter names to values
-  virtual absl::StatusOr<CelValue> Evaluate(
-      const BaseActivation& activation) const = 0;
-};
-
-// Base class for Expression Builder implementations
-// Provides user with factory to register extension functions.
-// ExpressionBuilder MUST NOT be destroyed before CelExpression objects
-// it built.
-class CelExpressionBuilder {
- public:
-  virtual ~CelExpressionBuilder() = default;
-
-  // Creates CelExpression object from AST tree.
-  // expr specifies root of AST tree
-  virtual absl::StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google_api_expr_v1alpha1_Expr* expr,
-      const google_api_expr_v1alpha1_SourceInfo* source_info) const = 0;
-
-  virtual absl::StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google_api_expr_v1alpha1_Expr* expr,
-      const google_api_expr_v1alpha1_SourceInfo* source_info,
-      std::vector<absl::Status>* warnings) const = 0;
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H

data/src/core/lib/security/authorization/mock_cel/cel_value.h

@@ -1,97 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H
-
-// CelValue is a holder, capable of storing all kinds of data
-// supported by CEL.
-// CelValue defines explicitly typed/named getters/setters.
-// When storing pointers to objects, CelValue does not accept ownership
-// to them and does not control their lifecycle. Instead objects are expected
-// to be either external to expression evaluation, and controlled beyond the
-// scope or to be allocated and associated with some allocation/ownership
-// controller (Arena).
-// Usage examples:
-// (a) For primitive types:
-//    CelValue value = CelValue::CreateInt64(1);
-// (b) For string:
-//    std::string* msg("test");
-//    CelValue value = CelValue::CreateString(msg);
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-
-#include "absl/memory/memory.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// Break cyclic depdendencies for container types.
-class CelMap {
- public:
-  CelMap() = default;
-};
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this class will be removed.
-class CelValue {
- public:
-  // Default constructor.
-  // Creates CelValue with null data type.
-  CelValue() : CelValue(nullptr) {}
-
-  // We will use factory methods instead of public constructors
-  // The reason for this is the high risk of implicit type conversions
-  // between bool/int/pointer types.
-  // We rely on copy elision to avoid extra copying.
-  static CelValue CreateNull() { return CelValue(nullptr); }
-
-  static CelValue CreateInt64(int64_t value) { return CreateNull(); }
-
-  static CelValue CreateUint64(uint64_t value) { return CreateNull(); }
-
-  static CelValue CreateStringView(absl::string_view value) {
-    return CreateNull();
-  }
-
-  static CelValue CreateString(const std::string* str) { return CreateNull(); }
-
-  static CelValue CreateMap(const CelMap* value) { return CreateNull(); }
-
- private:
-  // Constructs CelValue wrapping value supplied as argument.
-  // Value type T should be supported by specification of ValueHolder.
-  template <class T>
-  explicit CelValue(T value) {}
-};
-
-// CelMap implementation that uses STL map container as backing storage.
-class ContainerBackedMapImpl : public CelMap {
- public:
-  ContainerBackedMapImpl() = default;
-
-  static std::unique_ptr<CelMap> Create(
-      absl::Span<std::pair<CelValue, CelValue>> key_values) {
-    return absl::make_unique<ContainerBackedMapImpl>();
-  }
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H

data/src/core/lib/security/authorization/mock_cel/evaluator_core.h

@@ -1,67 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-#include <set>
-#include <vector>
-
-#include "absl/status/statusor.h"
-
-#include "google/api/expr/v1alpha1/syntax.upb.h"
-#include "src/core/lib/security/authorization/mock_cel/activation.h"
-#include "src/core/lib/security/authorization/mock_cel/cel_expression.h"
-#include "src/core/lib/security/authorization/mock_cel/cel_value.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-class ExecutionPath {
- public:
-  ExecutionPath() = default;
-};
-
-// Implementation of the CelExpression that utilizes flattening
-// of the expression tree.
-class CelExpressionFlatImpl : public CelExpression {
-  // Constructs CelExpressionFlatImpl instance.
-  // path is flat execution path that is based upon
-  // flattened AST tree. Max iterations dictates the maximum number of
-  // iterations in the comprehension expressions (use 0 to disable the upper
-  // bound).
- public:
-  CelExpressionFlatImpl(const google_api_expr_v1alpha1_Expr* root_expr,
-                        ExecutionPath path, int max_iterations,
-                        std::set<std::string> iter_variable_names,
-                        bool enable_unknowns = false,
-                        bool enable_unknown_function_results = false) {}
-
-  // Implementation of CelExpression evaluate method.
-  absl::StatusOr<CelValue> Evaluate(
-      const BaseActivation& activation) const override {
-    return CelValue::CreateNull();
-  }
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H

data/src/core/lib/security/authorization/mock_cel/flat_expr_builder.h

@@ -1,57 +0,0 @@
-// Copyright 2020 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.
-
-#ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-
-#include "src/core/lib/security/authorization/mock_cel/evaluator_core.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-// CelExpressionBuilder implementation.
-// Builds instances of CelExpressionFlatImpl.
-class FlatExprBuilder : public CelExpressionBuilder {
- public:
-  FlatExprBuilder() = default;
-
-  absl::StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google_api_expr_v1alpha1_Expr* expr,
-      const google_api_expr_v1alpha1_SourceInfo* source_info) const override {
-    ExecutionPath path;
-    return absl::make_unique<CelExpressionFlatImpl>(nullptr, path, 0,
-                                                    std::set<std::string>{});
-  }
-
-  absl::StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google_api_expr_v1alpha1_Expr* expr,
-      const google_api_expr_v1alpha1_SourceInfo* source_info,
-      std::vector<absl::Status>* warnings) const override {
-    ExecutionPath path;
-    return absl::make_unique<CelExpressionFlatImpl>(nullptr, path, 0,
-                                                    std::set<std::string>{});
-  }
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H