grpc 1.66.0 → 1.67.0.pre1

data/src/core/xds/grpc/xds_metadata_parser.cc

@@ -0,0 +1,143 @@
+// Copyright 2018 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 "src/core/xds/grpc/xds_metadata_parser.h"
+
+#include <memory>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+#include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upb.h"
+#include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upbdefs.h"
+#include "upb/base/string_view.h"
+#include "upb/text/encode.h"
+
+#include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/util/string.h"
+#include "src/core/util/upb_utils.h"
+#include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/grpc/xds_common_types_parser.h"
+
+namespace grpc_core {
+
+// TODO(roth): Remove this once GCP auth filter support is stable.
+bool XdsGcpAuthFilterEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_GCP_AUTHENTICATION_FILTER");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
+namespace {
+
+std::unique_ptr<XdsMetadataValue> ParseGcpAuthnAudience(
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) {
+  absl::string_view* serialized_proto =
+      absl::get_if<absl::string_view>(&extension.value);
+  if (serialized_proto == nullptr) {
+    errors->AddError("could not parse audience metadata");
+    return nullptr;
+  }
+  auto* proto = envoy_extensions_filters_http_gcp_authn_v3_Audience_parse(
+      serialized_proto->data(), serialized_proto->size(), context.arena);
+  if (proto == nullptr) {
+    errors->AddError("could not parse audience metadata");
+    return nullptr;
+  }
+  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
+    const upb_MessageDef* msg_type =
+        envoy_extensions_filters_http_gcp_authn_v3_Audience_getmsgdef(
+            context.symtab);
+    char buf[10240];
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(proto), msg_type,
+                   nullptr, 0, buf, sizeof(buf));
+    VLOG(2) << "[xds_client " << context.client
+            << "] cluster metadata Audience: " << buf;
+  }
+  absl::string_view url = UpbStringToAbsl(
+      envoy_extensions_filters_http_gcp_authn_v3_Audience_url(proto));
+  if (url.empty()) {
+    ValidationErrors::ScopedField field(errors, ".url");
+    errors->AddError("must be non-empty");
+    return nullptr;
+  }
+  return std::make_unique<XdsGcpAuthnAudienceMetadataValue>(url);
+}
+
+}  // namespace
+
+XdsMetadataMap ParseXdsMetadataMap(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_core_v3_Metadata* metadata, ValidationErrors* errors) {
+  XdsMetadataMap metadata_map;
+  if (metadata == nullptr) return metadata_map;  // Not present == empty.
+  // First, try typed_filter_metadata.
+  size_t iter = kUpb_Map_Begin;
+  const envoy_config_core_v3_Metadata_TypedFilterMetadataEntry* typed_entry;
+  while (
+      (typed_entry = envoy_config_core_v3_Metadata_typed_filter_metadata_next(
+           metadata, &iter)) != nullptr) {
+    absl::string_view key = UpbStringToAbsl(
+        envoy_config_core_v3_Metadata_TypedFilterMetadataEntry_key(
+            typed_entry));
+    ValidationErrors::ScopedField field(
+        errors, absl::StrCat(".typed_filter_metadata[", key, "]"));
+    auto extension = ExtractXdsExtension(
+        context,
+        envoy_config_core_v3_Metadata_TypedFilterMetadataEntry_value(
+            typed_entry),
+        errors);
+    if (!extension.has_value()) continue;
+    // TODO(roth): If we ever need to support another type here, refactor
+    // this into a separate registry.
+    if (XdsGcpAuthFilterEnabled() &&
+        extension->type == XdsGcpAuthnAudienceMetadataValue::Type()) {
+      auto metadata_value =
+          ParseGcpAuthnAudience(context, std::move(*extension), errors);
+      if (metadata_value != nullptr) {
+        metadata_map.Insert(key, std::move(metadata_value));
+      }
+    }
+  }
+  // Then, try filter_metadata.
+  iter = kUpb_Map_Begin;
+  const envoy_config_core_v3_Metadata_FilterMetadataEntry* entry;
+  while ((entry = envoy_config_core_v3_Metadata_filter_metadata_next(
+              metadata, &iter)) != nullptr) {
+    absl::string_view key = UpbStringToAbsl(
+        envoy_config_core_v3_Metadata_FilterMetadataEntry_key(entry));
+    auto json = ParseProtobufStructToJson(
+        context,
+        envoy_config_core_v3_Metadata_FilterMetadataEntry_value(entry));
+    if (!json.ok()) {
+      ValidationErrors::ScopedField field(
+          errors, absl::StrCat(".filter_metadata[", key, "]"));
+      errors->AddError(json.status().message());
+    }
+    // Add only if not already added from typed_filter_metadata.
+    else if (metadata_map.Find(key) == nullptr) {
+      metadata_map.Insert(
+          key, std::make_unique<XdsStructMetadataValue>(std::move(*json)));
+    }
+  }
+  return metadata_map;
+}
+
+}  // namespace grpc_core

data/src/core/xds/grpc/xds_metadata_parser.h

@@ -0,0 +1,36 @@
+//
+// Copyright 2024 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_SRC_CORE_XDS_GRPC_XDS_METADATA_PARSER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_METADATA_PARSER_H
+
+#include "envoy/config/core/v3/base.upb.h"
+
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/xds/grpc/xds_metadata.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+
+namespace grpc_core {
+
+bool XdsGcpAuthFilterEnabled();
+
+XdsMetadataMap ParseXdsMetadataMap(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_core_v3_Metadata* metadata, ValidationErrors* errors);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_METADATA_PARSER_H

data/src/core/xds/grpc/xds_route_config_parser.cc

@@ -441,7 +441,7 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
     }
     absl::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
         filter_impl->GenerateFilterConfigOverride(
-            context, std::move(*extension_to_use), errors);
+            key, context, std::move(*extension_to_use), errors);
     if (filter_config.has_value()) {
       typed_per_filter_config[std::string(key)] = std::move(*filter_config);
     }
@@ -474,18 +474,13 @@ XdsRouteConfigResource::RetryPolicy RetryPolicyParse(
       }
     }
   }
-  const google_protobuf_UInt32Value* num_retries =
-      envoy_config_route_v3_RetryPolicy_num_retries(retry_policy_proto);
-  if (num_retries != nullptr) {
-    uint32_t num_retries_value = google_protobuf_UInt32Value_value(num_retries);
-    if (num_retries_value == 0) {
-      ValidationErrors::ScopedField field(errors, ".num_retries");
-      errors->AddError("must be greater than 0");
-    } else {
-      retry_policy.num_retries = num_retries_value;
-    }
-  } else {
-    retry_policy.num_retries = 1;
+  retry_policy.num_retries =
+      ParseUInt32Value(
+          envoy_config_route_v3_RetryPolicy_num_retries(retry_policy_proto))
+          .value_or(1);
+  if (retry_policy.num_retries == 0) {
+    ValidationErrors::ScopedField field(errors, ".num_retries");
+    errors->AddError("must be greater than 0");
   }
   const envoy_config_route_v3_RetryPolicy_RetryBackOff* backoff =
       envoy_config_route_v3_RetryPolicy_retry_back_off(retry_policy_proto);
@@ -692,14 +687,14 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
         errors->AddError("must be non-empty");
       }
       // weight
-      const google_protobuf_UInt32Value* weight_proto =
+      auto weight = ParseUInt32Value(
           envoy_config_route_v3_WeightedCluster_ClusterWeight_weight(
-              cluster_proto);
-      if (weight_proto == nullptr) {
+              cluster_proto));
+      if (!weight.has_value()) {
         ValidationErrors::ScopedField field(errors, ".weight");
         errors->AddError("field not present");
       } else {
-        cluster.weight = google_protobuf_UInt32Value_value(weight_proto);
+        cluster.weight = *weight;
         if (cluster.weight == 0) continue;
         total_weight += cluster.weight;
       }

data/src/core/xds/grpc/xds_routing.cc

@@ -31,7 +31,6 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -216,23 +215,21 @@ const XdsHttpFilterImpl::FilterConfig* FindFilterConfigOverride(
   return nullptr;
 }
 
-}  // namespace
-
 absl::StatusOr<XdsRouting::GeneratePerHttpFilterConfigsResult>
-XdsRouting::GeneratePerHTTPFilterConfigs(
+GeneratePerHTTPFilterConfigs(
     const XdsHttpFilterRegistry& http_filter_registry,
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         http_filters,
-    const XdsRouteConfigResource::VirtualHost& vhost,
-    const XdsRouteConfigResource::Route& route,
-    const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
-        cluster_weight,
-    const ChannelArgs& args) {
-  GeneratePerHttpFilterConfigsResult result;
+    const ChannelArgs& args,
+    absl::FunctionRef<absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>(
+        const XdsHttpFilterImpl&,
+        const XdsListenerResource::HttpConnectionManager::HttpFilter&)>
+        generate_service_config) {
+  XdsRouting::GeneratePerHttpFilterConfigsResult result;
   result.args = args;
   for (const auto& http_filter : http_filters) {
     // Find filter.  This is guaranteed to succeed, because it's checked
-    // at config validation time in the XdsApi code.
+    // at config validation time in the listener parsing code.
     const XdsHttpFilterImpl* filter_impl =
         http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
@@ -243,22 +240,60 @@ XdsRouting::GeneratePerHTTPFilterConfigs(
     // Allow filter to add channel args that may affect service config
     // parsing.
     result.args = filter_impl->ModifyChannelArgs(result.args);
-    // Find config override, if any.
-    const XdsHttpFilterImpl::FilterConfig* config_override =
-        FindFilterConfigOverride(http_filter.name, vhost, route,
-                                 cluster_weight);
     // Generate service config for filter.
-    auto method_config_field =
-        filter_impl->GenerateServiceConfig(http_filter.config, config_override);
-    if (!method_config_field.ok()) {
+    auto service_config_field =
+        generate_service_config(*filter_impl, http_filter);
+    if (!service_config_field.ok()) {
       return absl::FailedPreconditionError(absl::StrCat(
-          "failed to generate method config for HTTP filter ", http_filter.name,
-          ": ", method_config_field.status().ToString()));
+          "failed to generate service config for HTTP filter ",
+          http_filter.name, ": ", service_config_field.status().ToString()));
     }
-    result.per_filter_configs[method_config_field->service_config_field_name]
-        .push_back(method_config_field->element);
+    if (service_config_field->service_config_field_name.empty()) continue;
+    result.per_filter_configs[service_config_field->service_config_field_name]
+        .push_back(service_config_field->element);
   }
   return result;
 }
 
+}  // namespace
+
+absl::StatusOr<XdsRouting::GeneratePerHttpFilterConfigsResult>
+XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
+    const XdsHttpFilterRegistry& http_filter_registry,
+    const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
+        http_filters,
+    const XdsRouteConfigResource::VirtualHost& vhost,
+    const XdsRouteConfigResource::Route& route,
+    const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
+        cluster_weight,
+    const ChannelArgs& args) {
+  return GeneratePerHTTPFilterConfigs(
+      http_filter_registry, http_filters, args,
+      [&](const XdsHttpFilterImpl& filter_impl,
+          const XdsListenerResource::HttpConnectionManager::HttpFilter&
+              http_filter) {
+        const XdsHttpFilterImpl::FilterConfig* config_override =
+            FindFilterConfigOverride(http_filter.name, vhost, route,
+                                     cluster_weight);
+        // Generate service config for filter.
+        return filter_impl.GenerateMethodConfig(http_filter.config,
+                                                config_override);
+      });
+}
+
+absl::StatusOr<XdsRouting::GeneratePerHttpFilterConfigsResult>
+XdsRouting::GeneratePerHTTPFilterConfigsForServiceConfig(
+    const XdsHttpFilterRegistry& http_filter_registry,
+    const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
+        http_filters,
+    const ChannelArgs& args) {
+  return GeneratePerHTTPFilterConfigs(
+      http_filter_registry, http_filters, args,
+      [&](const XdsHttpFilterImpl& filter_impl,
+          const XdsListenerResource::HttpConnectionManager::HttpFilter&
+              http_filter) {
+        return filter_impl.GenerateServiceConfig(http_filter.config);
+      });
+}
+
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_routing.h

@@ -88,9 +88,9 @@ class XdsRouting final {
     ChannelArgs args;
   };
 
-  // Generates a map of per_filter_configs. \a args is consumed.
+  // Generates per-HTTP filter configs for a method config.
   static absl::StatusOr<GeneratePerHttpFilterConfigsResult>
-  GeneratePerHTTPFilterConfigs(
+  GeneratePerHTTPFilterConfigsForMethodConfig(
       const XdsHttpFilterRegistry& http_filter_registry,
       const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
           http_filters,
@@ -99,6 +99,14 @@ class XdsRouting final {
       const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
           cluster_weight,
       const ChannelArgs& args);
+
+  // Generates per-HTTP filter configs for the top-level service config.
+  static absl::StatusOr<GeneratePerHttpFilterConfigsResult>
+  GeneratePerHTTPFilterConfigsForServiceConfig(
+      const XdsHttpFilterRegistry& http_filter_registry,
+      const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
+          http_filters,
+      const ChannelArgs& args);
 };
 
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_transport_grpc.cc

@@ -34,7 +34,6 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/impl/propagation_bits.h>
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/client_channel/client_channel_filter.h"