grpc 1.70.1 → 1.71.0

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

@@ -17,10 +17,10 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/address.upbdefs.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upb.h"
@@ -34,6 +34,9 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "upb/base/string_view.h"
+#include "upb/message/array.h"
+#include "upb/message/map.h"
+#include "upb/message/message.h"
 #include "upb/text/encode.h"
 
 namespace grpc_core {
@@ -53,7 +56,7 @@ 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);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_proto == nullptr) {
     errors->AddError("could not parse audience metadata");
     return nullptr;
@@ -64,7 +67,7 @@ std::unique_ptr<XdsMetadataValue> ParseGcpAuthnAudience(
     errors->AddError("could not parse audience metadata");
     return nullptr;
   }
-  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client) && ABSL_VLOG_IS_ON(2)) {
     const upb_MessageDef* msg_type =
         envoy_extensions_filters_http_gcp_authn_v3_Audience_getmsgdef(
             context.symtab);
@@ -88,7 +91,7 @@ std::unique_ptr<XdsMetadataValue> ParseAddress(
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) {
   absl::string_view* serialized_proto =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_proto == nullptr) {
     errors->AddError("could not parse address metadata");
     return nullptr;
@@ -99,7 +102,7 @@ std::unique_ptr<XdsMetadataValue> ParseAddress(
     errors->AddError("could not parse address metadata");
     return nullptr;
   }
-  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client) && ABSL_VLOG_IS_ON(2)) {
     const upb_MessageDef* msg_type =
         envoy_config_core_v3_Address_getmsgdef(context.symtab);
     char buf[10240];
@@ -126,56 +129,66 @@ XdsMetadataMap ParseXdsMetadataMap(
   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 start to need a lot of types here, refactor
-    // this into a separate registry.
-    std::unique_ptr<XdsMetadataValue> metadata_value;
-    if (XdsGcpAuthFilterEnabled() &&
-        extension->type == XdsGcpAuthnAudienceMetadataValue::Type()) {
-      metadata_value =
-          ParseGcpAuthnAudience(context, std::move(*extension), errors);
-    } else if (XdsHttpConnectEnabled() &&
-               extension->type == XdsAddressMetadataValue::Type()) {
-      metadata_value = ParseAddress(context, std::move(*extension), errors);
-    }
-    if (metadata_value != nullptr) {
-      metadata_map.Insert(key, std::move(metadata_value));
+  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+  // v30.0.
+  envoy_config_core_v3_Metadata* metadata_upb =
+      (envoy_config_core_v3_Metadata*)metadata;
+  const upb_Map* typed_filter_metadata_upb_map =
+      _envoy_config_core_v3_Metadata_typed_filter_metadata_upb_map(
+          metadata_upb);
+  if (typed_filter_metadata_upb_map) {
+    size_t iter = kUpb_Map_Begin;
+    upb_MessageValue k, v;
+    while (upb_Map_Next(typed_filter_metadata_upb_map, &k, &v, &iter)) {
+      upb_StringView typed_filter_metadata_key_view = k.str_val;
+      const google_protobuf_Any* typed_filter_metadata_val =
+          (google_protobuf_Any*)v.msg_val;
+      absl::string_view key = UpbStringToAbsl(typed_filter_metadata_key_view);
+      ValidationErrors::ScopedField field(
+          errors, absl::StrCat(".typed_filter_metadata[", key, "]"));
+      auto extension =
+          ExtractXdsExtension(context, typed_filter_metadata_val, errors);
+      if (!extension.has_value()) continue;
+      // TODO(roth): If we start to need a lot of types here, refactor
+      // this into a separate registry.
+      std::unique_ptr<XdsMetadataValue> metadata_value;
+      if (XdsGcpAuthFilterEnabled() &&
+          extension->type == XdsGcpAuthnAudienceMetadataValue::Type()) {
+        metadata_value =
+            ParseGcpAuthnAudience(context, std::move(*extension), errors);
+      } else if (XdsHttpConnectEnabled() &&
+                 extension->type == XdsAddressMetadataValue::Type()) {
+        metadata_value = ParseAddress(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)));
+  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+  // v30.0.
+  const upb_Map* filter_metadata_upb_map =
+      _envoy_config_core_v3_Metadata_filter_metadata_upb_map(metadata_upb);
+  if (filter_metadata_upb_map) {
+    size_t iter = kUpb_Map_Begin;
+    upb_MessageValue k, v;
+    while (upb_Map_Next(filter_metadata_upb_map, &k, &v, &iter)) {
+      upb_StringView filter_metadata_key_view = k.str_val;
+      const google_protobuf_Struct* filter_metadata_val =
+          (google_protobuf_Struct*)v.msg_val;
+      absl::string_view key = UpbStringToAbsl(filter_metadata_key_view);
+      auto json = ParseProtobufStructToJson(context, filter_metadata_val);
+      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;

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

@@ -16,15 +16,15 @@
 
 #include "src/core/xds/grpc/xds_route_config.h"
 
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "re2/re2.h"
 #include "src/core/util/match.h"
 #include "src/core/util/matchers.h"
@@ -155,9 +155,7 @@ XdsRouteConfigResource::Route::RouteAction::ClusterWeight::ToString() const {
   contents.push_back(absl::StrCat("weight=", weight));
   if (!typed_per_filter_config.empty()) {
     std::vector<std::string> parts;
-    for (const auto& p : typed_per_filter_config) {
-      const std::string& key = p.first;
-      const auto& config = p.second;
+    for (const auto& [key, config] : typed_per_filter_config) {
       parts.push_back(absl::StrCat(key, "=", config.ToString()));
     }
     contents.push_back(absl::StrCat("typed_per_filter_config={",
@@ -211,10 +209,10 @@ std::string XdsRouteConfigResource::Route::ToString() const {
   std::vector<std::string> contents;
   contents.push_back(matchers.ToString());
   auto* route_action =
-      absl::get_if<XdsRouteConfigResource::Route::RouteAction>(&action);
+      std::get_if<XdsRouteConfigResource::Route::RouteAction>(&action);
   if (route_action != nullptr) {
     contents.push_back(absl::StrCat("route=", route_action->ToString()));
-  } else if (absl::holds_alternative<
+  } else if (std::holds_alternative<
                  XdsRouteConfigResource::Route::NonForwardingAction>(action)) {
     contents.push_back("non_forwarding_action={}");
   } else {
@@ -222,9 +220,7 @@ std::string XdsRouteConfigResource::Route::ToString() const {
   }
   if (!typed_per_filter_config.empty()) {
     contents.push_back("typed_per_filter_config={");
-    for (const auto& p : typed_per_filter_config) {
-      const std::string& name = p.first;
-      const auto& config = p.second;
+    for (const auto& [name, config] : typed_per_filter_config) {
       contents.push_back(absl::StrCat("  ", name, "=", config.ToString()));
     }
     contents.push_back("}");
@@ -251,9 +247,7 @@ std::string XdsRouteConfigResource::VirtualHost::ToString() const {
   }
   parts.push_back("  ]\n");
   parts.push_back("  typed_per_filter_config={\n");
-  for (const auto& p : typed_per_filter_config) {
-    const std::string& name = p.first;
-    const auto& config = p.second;
+  for (const auto& [name, config] : typed_per_filter_config) {
     parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
   }
   parts.push_back("  }\n");
@@ -272,8 +266,8 @@ std::string XdsRouteConfigResource::ToString() const {
     parts.push_back(vhost.ToString());
   }
   parts.push_back("cluster_specifier_plugins={\n");
-  for (const auto& it : cluster_specifier_plugin_map) {
-    parts.push_back(absl::StrFormat("%s={%s}\n", it.first, it.second));
+  for (const auto& [name, plugin] : cluster_specifier_plugin_map) {
+    parts.push_back(absl::StrFormat("%s={%s}\n", name, plugin));
   }
   parts.push_back("}");
   return absl::StrJoin(parts, "");

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

@@ -22,11 +22,11 @@
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "re2/re2.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/util/matchers.h"
@@ -73,7 +73,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
     struct Matchers {
       StringMatcher path_matcher;
       std::vector<HeaderMatcher> header_matchers;
-      absl::optional<uint32_t> fraction_per_million;
+      std::optional<uint32_t> fraction_per_million;
 
       bool operator==(const Matchers& other) const {
         return path_matcher == other.path_matcher &&
@@ -114,7 +114,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
           bool operator==(const ChannelId&) const { return true; }
         };
 
-        absl::variant<Header, ChannelId> policy;
+        std::variant<Header, ChannelId> policy;
         bool terminal = false;
 
         bool operator==(const HashPolicy& other) const {
@@ -153,18 +153,18 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
       };
 
       std::vector<HashPolicy> hash_policies;
-      absl::optional<RetryPolicy> retry_policy;
+      std::optional<RetryPolicy> retry_policy;
 
       // Action for this route.
-      absl::variant<ClusterName, std::vector<ClusterWeight>,
-                    ClusterSpecifierPluginName>
+      std::variant<ClusterName, std::vector<ClusterWeight>,
+                   ClusterSpecifierPluginName>
           action;
 
       // Storing the timeout duration from route action:
       // RouteAction.max_stream_duration.grpc_timeout_header_max or
       // RouteAction.max_stream_duration.max_stream_duration if the former is
       // not set.
-      absl::optional<Duration> max_stream_duration;
+      std::optional<Duration> max_stream_duration;
 
       bool auto_host_rewrite = false;
 
@@ -183,7 +183,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
       }
     };
 
-    absl::variant<UnknownAction, RouteAction, NonForwardingAction> action;
+    std::variant<UnknownAction, RouteAction, NonForwardingAction> action;
     TypedPerFilterConfig typed_per_filter_config;
 
     bool operator==(const Route& other) const {