grpc 1.83.1 → 1.84.0

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

@@ -0,0 +1,177 @@
+//
+// 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_grpc_service_parser.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "src/core/config/core_configuration.h"
+#include "src/core/util/down_cast.h"
+#include "src/core/util/upb_utils.h"
+#include "src/core/util/validation_errors.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/grpc/xds_common_types_parser.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+GrpcXdsServerTarget ParseXdsGrpcService(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_core_v3_GrpcService* grpc_service,
+    ValidationErrors* errors) {
+  if (grpc_service == nullptr) {
+    errors->AddError("field not set");
+    return GrpcXdsServerTarget(/*server_uri=*/"",
+                               /*channel_creds_config=*/nullptr,
+                               /*call_creds_configs=*/{});
+  }
+  // timeout
+  Duration timeout = Duration::Zero();
+  if (auto* timeout_proto =
+          envoy_config_core_v3_GrpcService_timeout(grpc_service);
+      timeout_proto != nullptr) {
+    ValidationErrors::ScopedField field(errors, ".timeout");
+    timeout = ParseDuration(timeout_proto, errors);
+    if (timeout <= Duration::Zero()) {
+      errors->AddError("duration must be positive");
+    }
+  }
+  // initial_metadata
+  std::vector<std::pair<std::string, std::string>> initial_metadata;
+  size_t initial_metadata_size;
+  auto* initial_metadata_proto =
+      envoy_config_core_v3_GrpcService_initial_metadata(grpc_service,
+                                                        &initial_metadata_size);
+  for (size_t i = 0; i < initial_metadata_size; ++i) {
+    ValidationErrors::ScopedField field(
+        errors, absl::StrCat(".initial_metadata[", i, "]"));
+    initial_metadata.push_back(
+        ParseXdsHeader(initial_metadata_proto[i], errors));
+  }
+  // google_grpc
+  ValidationErrors::ScopedField field(errors, ".google_grpc");
+  auto* google_grpc =
+      envoy_config_core_v3_GrpcService_google_grpc(grpc_service);
+  if (google_grpc == nullptr) {
+    errors->AddError("field not set");
+    return GrpcXdsServerTarget(/*server_uri=*/"",
+                               /*channel_creds_config=*/nullptr,
+                               /*call_creds_configs=*/{});
+  }
+  // target_uri
+  std::string target_uri = UpbStringToStdString(
+      envoy_config_core_v3_GrpcService_GoogleGrpc_target_uri(google_grpc));
+  if (!CoreConfiguration::Get().resolver_registry().IsValidTarget(target_uri)) {
+    ValidationErrors::ScopedField field(errors, ".target_uri");
+    errors->AddError("invalid target URI");
+  }
+  // credentials
+  RefCountedPtr<const ChannelCredsConfig> channel_creds_config;
+  std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs;
+  if (DownCast<const GrpcXdsServer&>(context.server).TrustedXdsServer()) {
+    // Trusted xDS server.  Use credentials from the GoogleGrpc proto.
+    // First, look at channel creds.
+    {
+      ValidationErrors::ScopedField field(errors,
+                                          ".channel_credentials_plugin");
+      size_t size;
+      const auto* const* channel_creds_plugin =
+          envoy_config_core_v3_GrpcService_GoogleGrpc_channel_credentials_plugin(
+              google_grpc, &size);
+      if (size == 0) {
+        errors->AddError("field not set");
+      } else {
+        const auto& registry =
+            CoreConfiguration::Get().channel_creds_registry();
+        const auto& certificate_providers =
+            DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+                .certificate_providers();
+        for (size_t i = 0; i < size; ++i) {
+          ValidationErrors::ScopedField field(errors,
+                                              absl::StrCat("[", i, "]"));
+          auto extension =
+              ExtractXdsExtension(context, channel_creds_plugin[i], errors);
+          if (!extension.has_value()) continue;
+          if (!registry.IsProtoSupported(extension->type)) continue;
+          absl::string_view* serialized_config =
+              std::get_if<absl::string_view>(&extension->value);
+          if (serialized_config == nullptr) {
+            errors->AddError("can't decode config");
+            continue;
+          }
+          channel_creds_config =
+              registry.ParseProto(extension->type, *serialized_config,
+                                  certificate_providers, errors);
+          break;
+        }
+        if (channel_creds_config == nullptr) {
+          errors->AddError("no supported channel credentials type found");
+        }
+      }
+    }
+    // Now look at call creds.
+    {
+      ValidationErrors::ScopedField field(errors, ".call_credentials_plugin");
+      size_t size;
+      const auto* const* call_creds_plugin =
+          envoy_config_core_v3_GrpcService_GoogleGrpc_call_credentials_plugin(
+              google_grpc, &size);
+      const auto& registry = CoreConfiguration::Get().call_creds_registry();
+      for (size_t i = 0; i < size; ++i) {
+        ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
+        auto extension =
+            ExtractXdsExtension(context, call_creds_plugin[i], errors);
+        if (!extension.has_value()) continue;
+        if (!registry.IsProtoSupported(extension->type)) continue;
+        absl::string_view* serialized_config =
+            std::get_if<absl::string_view>(&extension->value);
+        if (serialized_config == nullptr) {
+          errors->AddError("can't decode config");
+          continue;
+        }
+        call_creds_configs.push_back(
+            registry.ParseProto(extension->type, *serialized_config, errors));
+      }
+    }
+  } else {
+    // Not a trusted xDS server.  Do lookup in bootstrap.
+    const auto& bootstrap =
+        DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap());
+    auto& allowed_grpc_services = bootstrap.allowed_grpc_services();
+    auto it = allowed_grpc_services.find(target_uri);
+    if (it == allowed_grpc_services.end()) {
+      ValidationErrors::ScopedField field(errors, ".target_uri");
+      errors->AddError(
+          "service not present in \"allowed_grpc_services\" "
+          "in bootstrap config");
+    } else {
+      channel_creds_config = it->second.channel_creds_config;
+      call_creds_configs = it->second.call_creds_configs;
+    }
+  }
+  return GrpcXdsServerTarget(target_uri, std::move(channel_creds_config),
+                             std::move(call_creds_configs),
+                             std::move(initial_metadata), timeout);
+}
+
+}  // namespace grpc_core

data/src/core/{resolver/dns/c_ares/dns_resolver_ares.h → xds/grpc/xds_grpc_service_parser.h}

@@ -1,4 +1,5 @@
-// Copyright 2022 The gRPC Authors
+//
+// 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.
@@ -11,19 +12,23 @@
 // 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_RESOLVER_DNS_C_ARES_DNS_RESOLVER_ARES_H
-#define GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_DNS_RESOLVER_ARES_H
+//
 
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_GRPC_SERVICE_PARSER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_GRPC_SERVICE_PARSER_H
 
-#include "src/core/config/core_configuration.h"
-#include "absl/strings/string_view.h"
+#include "envoy/config/core/v3/grpc_service.upb.h"
+#include "src/core/util/validation_errors.h"
+#include "src/core/xds/grpc/xds_server_grpc.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
 
 namespace grpc_core {
 
-bool ShouldUseAresDnsResolver(absl::string_view resolver_env);
-void RegisterAresDnsResolver(CoreConfiguration::Builder*);
+GrpcXdsServerTarget ParseXdsGrpcService(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_core_v3_GrpcService* grpc_service,
+    ValidationErrors* errors);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_DNS_RESOLVER_ARES_H
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_GRPC_SERVICE_PARSER_H

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

@@ -26,6 +26,7 @@
 #include "src/core/filter/composite/composite_filter.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
 #include "src/core/xds/grpc/xds_http_filter_registry.h"
 #include "src/core/xds/grpc/xds_matcher.h"
@@ -37,15 +38,16 @@
 
 namespace grpc_core {
 
-absl::string_view XdsHttpCompositeFilter::ConfigProtoName() const {
+absl::string_view XdsHttpCompositeFilterFactory::ConfigProtoName() const {
   return "envoy.extensions.common.matching.v3.ExtensionWithMatcher";
 }
 
-absl::string_view XdsHttpCompositeFilter::OverrideConfigProtoName() const {
+absl::string_view XdsHttpCompositeFilterFactory::OverrideConfigProtoName()
+    const {
   return "envoy.extensions.common.matching.v3.ExtensionWithMatcherPerRoute";
 }
 
-void XdsHttpCompositeFilter::PopulateSymtab(upb_DefPool* symtab) const {
+void XdsHttpCompositeFilterFactory::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_common_matching_v3_ExtensionWithMatcher_getmsgdef(symtab);
   envoy_extensions_common_matching_v3_ExtensionWithMatcherPerRoute_getmsgdef(
       symtab);
@@ -56,13 +58,14 @@ void XdsHttpCompositeFilter::PopulateSymtab(upb_DefPool* symtab) const {
       symtab);
 }
 
-void XdsHttpCompositeFilter::AddFilter(
+void XdsHttpCompositeFilterFactory::AddFilter(
     FilterChainBuilder& builder,
     RefCountedPtr<const FilterConfig> config) const {
   builder.AddFilter<CompositeFilter>(std::move(config));
 }
 
-const grpc_channel_filter* XdsHttpCompositeFilter::channel_filter() const {
+const grpc_channel_filter* XdsHttpCompositeFilterFactory::channel_filter()
+    const {
   return &CompositeFilter::kFilterVtable;
 }
 
@@ -167,22 +170,21 @@ class ExecuteFilterActionFactory final : public XdsMatcherActionFactory {
         envoy_config_core_v3_TypedExtensionConfig_typed_config(typed_config);
     ValidationErrors::ScopedField field(errors, ".typed_config.typed_config");
     auto extension = ExtractXdsExtension(context, any, errors);
-    const XdsHttpFilterImpl* filter_impl = nullptr;
+    const XdsHttpFilterFactory* factory = nullptr;
     RefCountedPtr<const FilterConfig> config;
     if (extension.has_value()) {
-      filter_impl =
-          http_filter_registry.GetFilterForTopLevelType(extension->type);
-      if (filter_impl == nullptr) {
+      factory = http_filter_registry.GetFilterForTopLevelType(extension->type);
+      if (factory == nullptr) {
         errors->AddError("unsupported filter type");
-      } else if (filter_impl->IsTerminalFilter()) {
+      } else if (factory->IsTerminalFilter()) {
         errors->AddError(
             "terminal filters may not be used under composite filter");
       } else {
         config =
-            filter_impl->ParseTopLevelConfig(name, context, *extension, errors);
+            factory->ParseTopLevelConfig(name, context, *extension, errors);
       }
     }
-    return {filter_impl, std::move(config)};
+    return {factory, std::move(config)};
   }
 };
 
@@ -200,7 +202,8 @@ std::unique_ptr<XdsMatcher> ParseMatcher(
 
 }  // namespace
 
-RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::ParseTopLevelConfig(
+RefCountedPtr<const FilterConfig>
+XdsHttpCompositeFilterFactory::ParseTopLevelConfig(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context,
     const XdsExtension& extension, ValidationErrors* errors) const {
@@ -251,7 +254,8 @@ RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::ParseTopLevelConfig(
   return config;
 }
 
-RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::ParseOverrideConfig(
+RefCountedPtr<const FilterConfig>
+XdsHttpCompositeFilterFactory::ParseOverrideConfig(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context,
     const XdsExtension& extension, ValidationErrors* errors) const {
@@ -279,17 +283,17 @@ RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::ParseOverrideConfig(
   return config;
 }
 
-RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::MergeConfigs(
+RefCountedPtr<const FilterConfig> XdsHttpCompositeFilterFactory::MergeConfigs(
     RefCountedPtr<const FilterConfig> top_level_config,
     RefCountedPtr<const FilterConfig> virtual_host_override_config,
     RefCountedPtr<const FilterConfig> route_override_config,
     RefCountedPtr<const FilterConfig> cluster_weight_override_config,
-    Blackboard& blackboard) const {
+    XdsTransportFactory& transport_factory, Blackboard& blackboard) const {
   // Get the config to use via our base class.
-  auto config_to_use = XdsHttpFilterImpl::MergeConfigs(
+  auto config_to_use = XdsHttpFilterFactory::MergeConfigs(
       std::move(top_level_config), std::move(virtual_host_override_config),
       std::move(route_override_config),
-      std::move(cluster_weight_override_config), blackboard);
+      std::move(cluster_weight_override_config), transport_factory, blackboard);
   auto& composite_config =
       DownCast<const CompositeFilter::Config&>(*config_to_use);
   if (composite_config.matcher == nullptr) return config_to_use;
@@ -304,12 +308,13 @@ RefCountedPtr<const FilterConfig> XdsHttpCompositeFilter::MergeConfigs(
         DownCast<const CompositeFilter::ExecuteFilterAction&>(action);
     auto& merged_configs = new_config->merged_config_map[&action];
     GRPC_CHECK(merged_configs.empty());
-    for (const auto& [filter_impl, filter_config] :
+    for (const auto& [factory, filter_config] :
          execute_filter_action.filter_chain()) {
-      merged_configs.push_back(filter_impl->MergeConfigs(
+      merged_configs.push_back(factory->MergeConfigs(
           filter_config, /*virtual_host_override_config=*/nullptr,
           /*route_override_config=*/nullptr,
-          /*cluster_weight_override_config=*/nullptr, blackboard));
+          /*cluster_weight_override_config=*/nullptr, transport_factory,
+          blackboard));
     }
   });
   return new_config;

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

@@ -19,19 +19,19 @@
 
 #include <optional>
 
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
+#include "src/core/xds/xds_client/xds_transport.h"
 #include "upb/reflection/def.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
-class XdsHttpCompositeFilter final : public XdsHttpFilterImpl {
+class XdsHttpCompositeFilterFactory final : public XdsHttpFilterFactory {
  public:
   absl::string_view ConfigProtoName() const override;
   absl::string_view OverrideConfigProtoName() const override;
@@ -77,9 +77,10 @@ class XdsHttpCompositeFilter final : public XdsHttpFilterImpl {
       RefCountedPtr<const FilterConfig> virtual_host_override_config,
       RefCountedPtr<const FilterConfig> route_override_config,
       RefCountedPtr<const FilterConfig> cluster_weight_override_config,
+      XdsTransportFactory& transport_factory,
       Blackboard& blackboard) const override;
   bool IsSupportedOnClients() const override { return true; }
-  bool IsSupportedOnServers() const override { return false; }
+  bool IsSupportedOnServers() const override { return true; }
 };
 
 }  // namespace grpc_core