Add minimal and testing descriptor pools

PiperOrigin-RevId: 658448217

Author: jcking

bazel/BUILD

@@ -7,3 +7,17 @@ java_binary(
 )
 
 package(default_visibility = ["//visibility:public"])
+
+cc_binary(
+    name = "cel_cc_embed",
+    srcs = ["cel_cc_embed.cc"],
+    visibility = ["//:__subpackages__"],
+    deps = [
+        "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/flags:parse",
+        "@com_google_absl//absl/log:absl_check",
+        "@com_google_absl//absl/log:initialize",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/types:span",
+    ],
+)

bazel/cel_cc_embed.bzl

@@ -0,0 +1,27 @@
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#     https://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.
+
+"""
+Provides the `cel_cc_embed` build rule.
+"""
+
+def cel_cc_embed(name, src, testonly = False):
+    native.genrule(
+        name = name,
+        srcs = [src],
+        outs = ["{}.inc".format(name)],
+        cmd = "$(location //bazel:cel_cc_embed) --in=$< --out=$@",
+        tools = ["//bazel:cel_cc_embed"],
+        testonly = testonly,
+    )

bazel/cel_cc_embed.cc

@@ -0,0 +1,85 @@
+// Copyright 2024 Google LLC
+//
+// 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
+//
+//     https://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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/absl_check.h"
+#include "absl/log/initialize.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/types/span.h"
+
+ABSL_FLAG(std::string, in, "", "");
+ABSL_FLAG(std::string, out, "", "");
+
+namespace {
+
+std::vector<uint8_t> ReadFile(const std::string& path) {
+  ABSL_CHECK(!path.empty()) << "--in is required";
+  std::ifstream file(path);
+  ABSL_CHECK(file.is_open()) << path;
+  file.seekg(0, file.end);
+  ABSL_CHECK(file.good());
+  size_t size = static_cast<size_t>(file.tellg());
+  file.seekg(0, file.beg);
+  ABSL_CHECK(file.good());
+  std::vector<uint8_t> buffer;
+  buffer.resize(size);
+  file.read(reinterpret_cast<char*>(buffer.data()), size);
+  ABSL_CHECK(file.good());
+  return buffer;
+}
+
+void WriteFile(const std::string& path, absl::Span<const char> data) {
+  ABSL_CHECK(!path.empty()) << "--out is required";
+  std::ofstream file(path);
+  ABSL_CHECK(file.is_open()) << path;
+  file.write(data.data(), data.size());
+  ABSL_CHECK(file.good());
+  file.flush();
+  ABSL_CHECK(file.good());
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  {
+    auto args = absl::ParseCommandLine(argc, argv);
+    ABSL_CHECK(args.empty() || args.size() == 1)
+        << "unexpected positional args: " << absl::StrJoin(args, ", ");
+  }
+  absl::InitializeLog();
+
+  auto in_buffer = ReadFile(absl::GetFlag(FLAGS_in));
+  std::string out_buffer;
+  out_buffer.reserve(in_buffer.size() * 6);
+  for (const auto& in_byte : in_buffer) {
+    absl::StrAppend(&out_buffer, "0x",
+                    absl::Hex(in_byte, absl::PadSpec::kZeroPad2), ", ");
+  }
+  if (!in_buffer.empty()) {
+    // Replace last space with newline.
+    out_buffer.back() = '\n';
+  }
+  WriteFile(absl::GetFlag(FLAGS_out), out_buffer);
+
+  return EXIT_SUCCESS;
+}

bazel/cel_proto_transitive_descriptor_set.bzl

@@ -0,0 +1,47 @@
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#     https://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.
+
+"""
+Provides the `cel_proto_transitive_descriptor_set` build rule.
+"""
+
+load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo")
+
+def _cel_proto_transitive_descriptor_set(ctx):
+    output = ctx.actions.declare_file(ctx.attr.name + ".binarypb")
+    transitive_descriptor_sets = depset(transitive = [dep[ProtoInfo].transitive_descriptor_sets for dep in ctx.attr.deps])
+    args = ctx.actions.args()
+    args.use_param_file(param_file_arg = "%s", use_always = True)
+    args.add_all(transitive_descriptor_sets)
+    ctx.actions.run_shell(
+        outputs = [output],
+        inputs = transitive_descriptor_sets,
+        progress_message = "Joining descriptors.",
+        command = ("< \"$1\" xargs cat >{output}".format(output = output.path)),
+        arguments = [args],
+    )
+    return DefaultInfo(
+        files = depset([output]),
+        runfiles = ctx.runfiles(files = [output]),
+    )
+
+cel_proto_transitive_descriptor_set = rule(
+    attrs = {
+        "deps": attr.label_list(providers = [[ProtoInfo]]),
+    },
+    outputs = {
+        "out": "%{name}.binarypb",
+    },
+    implementation = _cel_proto_transitive_descriptor_set,
+)

internal/BUILD

@@ -12,6 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+load("//bazel:cel_cc_embed.bzl", "cel_cc_embed")
+load("//bazel:cel_proto_transitive_descriptor_set.bzl", "cel_proto_transitive_descriptor_set")
+
 package(default_visibility = ["//visibility:public"])
 
 licenses(["notice"])
@@ -517,3 +520,91 @@ cc_test(
         ":to_address",
     ],
 )
+
+cel_proto_transitive_descriptor_set(
+    name = "minimal_descriptor_set",
+    deps = [
+        "@com_google_protobuf//:any_proto",
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:struct_proto",
+        "@com_google_protobuf//:timestamp_proto",
+        "@com_google_protobuf//:wrappers_proto",
+    ],
+)
+
+cel_cc_embed(
+    name = "minimal_descriptor_set_embed",
+    src = ":minimal_descriptor_set",
+)
+
+cc_library(
+    name = "minimal_descriptor_pool",
+    srcs = ["minimal_descriptor_pool.cc"],
+    hdrs = ["minimal_descriptor_pool.h"],
+    textual_hdrs = [":minimal_descriptor_set_embed"],
+    deps = [
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/base:nullability",
+        "@com_google_absl//absl/log:absl_check",
+        "@com_google_protobuf//:protobuf",
+    ],
+)
+
+cc_test(
+    name = "minimal_descriptor_pool_test",
+    srcs = ["minimal_descriptor_pool_test.cc"],
+    deps = [
+        ":minimal_descriptor_pool",
+        ":testing",
+        "@com_google_protobuf//:protobuf",
+    ],
+)
+
+cel_proto_transitive_descriptor_set(
+    name = "testing_descriptor_set",
+    testonly = True,
+    deps = [
+        "@com_google_cel_spec//proto/test/v1/proto2:test_all_types_proto",
+        "@com_google_cel_spec//proto/test/v1/proto3:test_all_types_proto",
+        "@com_google_googleapis//google/api/expr/v1alpha1:checked_proto",
+        "@com_google_googleapis//google/api/expr/v1alpha1:eval_proto",
+        "@com_google_googleapis//google/api/expr/v1alpha1:explain_proto",
+        "@com_google_googleapis//google/api/expr/v1alpha1:syntax_proto",
+        "@com_google_googleapis//google/api/expr/v1alpha1:value_proto",
+        "@com_google_protobuf//:any_proto",
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:struct_proto",
+        "@com_google_protobuf//:timestamp_proto",
+        "@com_google_protobuf//:wrappers_proto",
+    ],
+)
+
+cel_cc_embed(
+    name = "testing_descriptor_set_embed",
+    testonly = True,
+    src = ":testing_descriptor_set",
+)
+
+cc_library(
+    name = "testing_descriptor_pool",
+    testonly = True,
+    srcs = ["testing_descriptor_pool.cc"],
+    hdrs = ["testing_descriptor_pool.h"],
+    textual_hdrs = [":testing_descriptor_set_embed"],
+    deps = [
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/base:nullability",
+        "@com_google_absl//absl/log:absl_check",
+        "@com_google_protobuf//:protobuf",
+    ],
+)
+
+cc_test(
+    name = "testing_descriptor_pool_test",
+    srcs = ["testing_descriptor_pool_test.cc"],
+    deps = [
+        ":testing",
+        ":testing_descriptor_pool",
+        "@com_google_protobuf//:protobuf",
+    ],
+)

internal/minimal_descriptor_pool.cc

@@ -0,0 +1,50 @@
+// Copyright 2024 Google LLC
+//
+// 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
+//
+//     https://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 "internal/minimal_descriptor_pool.h"
+
+#include <cstdint>
+
+#include "google/protobuf/descriptor.pb.h"
+#include "absl/base/attributes.h"
+#include "absl/base/macros.h"
+#include "absl/base/nullability.h"
+#include "absl/log/absl_check.h"
+#include "google/protobuf/descriptor.h"
+
+namespace cel::internal {
+
+namespace {
+
+ABSL_CONST_INIT const uint8_t kMinimalDescriptorSet[] = {
+#include "internal/minimal_descriptor_set_embed.inc"
+};
+
+}  // namespace
+
+absl::Nonnull<const google::protobuf::DescriptorPool*> GetMinimalDescriptorPool() {
+  static absl::Nonnull<const google::protobuf::DescriptorPool* const> pool = []() {
+    google::protobuf::FileDescriptorSet file_desc_set;
+    ABSL_CHECK(file_desc_set.ParseFromArray(  // Crash OK
+       kMinimalDescriptorSet, ABSL_ARRAYSIZE(kMinimalDescriptorSet)));
+    auto* pool = new google::protobuf::DescriptorPool();
+    for (const auto& file_desc : file_desc_set.file()) {
+      ABSL_CHECK(pool->BuildFile(file_desc) != nullptr);  // Crash OK
+    }
+    return pool;
+  }();
+  return pool;
+}
+
+}  // namespace cel::internal

internal/minimal_descriptor_pool.h

@@ -0,0 +1,35 @@
+// Copyright 2024 Google LLC
+//
+// 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
+//
+//     https://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 THIRD_PARTY_CEL_CPP_INTERNAL_MINIMAL_DESCRIPTOR_POOL_H_
+#define THIRD_PARTY_CEL_CPP_INTERNAL_MINIMAL_DESCRIPTOR_POOL_H_
+
+#include "absl/base/nullability.h"
+#include "google/protobuf/descriptor.h"
+
+namespace cel::internal {
+
+// GetMinimalDescriptorPool returns a pointer to a `google::protobuf::DescriptorPool`
+// which includes has the minimally necessary descriptors required by the Common
+// Expression Language. The returning `google::protobuf::DescriptorPool` is valid for the
+// lifetime of the process.
+//
+// This descriptor pool can be used as an underlay for another descriptor pool:
+//
+// google::protobuf::DescriptorPool my_descriptor_pool(GetMinimalDescriptorPool());
+absl::Nonnull<const google::protobuf::DescriptorPool*> GetMinimalDescriptorPool();
+
+}  // namespace cel::internal
+
+#endif  // THIRD_PARTY_CEL_CPP_INTERNAL_MINIMAL_DESCRIPTOR_POOL_H_