grpc 1.65.2 → 1.66.0

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

@@ -0,0 +1,80 @@
+//
+// 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.
+//
+
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+#include "envoy/config/route/v3/route.upb.h"
+#include "envoy/config/route/v3/route.upbdefs.h"
+#include "re2/re2.h"
+#include "upb/reflection/def.h"
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/matchers/matchers.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
+#include "src/core/xds/grpc/xds_http_filter.h"
+#include "src/core/xds/grpc/xds_route_config.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "src/core/xds/xds_client/xds_resource_type.h"
+#include "src/core/xds/xds_client/xds_resource_type_impl.h"
+
+namespace grpc_core {
+
+std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_route_v3_RouteConfiguration* route_config,
+    ValidationErrors* errors);
+
+class XdsRouteConfigResourceType final
+    : public XdsResourceTypeImpl<XdsRouteConfigResourceType,
+                                 XdsRouteConfigResource> {
+ public:
+  absl::string_view type_url() const override {
+    return "envoy.config.route.v3.RouteConfiguration";
+  }
+
+  DecodeResult Decode(const XdsResourceType::DecodeContext& context,
+                      absl::string_view serialized_resource) const override;
+
+  void InitUpbSymtab(XdsClient* xds_client,
+                     upb_DefPool* symtab) const override {
+    envoy_config_route_v3_RouteConfiguration_getmsgdef(symtab);
+    const auto& cluster_specifier_plugin_registry =
+        static_cast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
+            .cluster_specifier_plugin_registry();
+    cluster_specifier_plugin_registry.PopulateSymtab(symtab);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H

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

@@ -36,7 +36,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/matchers/matchers.h"
-#include "src/core/xds/grpc/xds_http_filters.h"
+#include "src/core/xds/grpc/xds_http_filter.h"
 
 namespace grpc_core {
 

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

@@ -33,7 +33,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/xds/grpc/xds_http_filters.h"
+#include "src/core/xds/grpc/xds_http_filter_registry.h"
 #include "src/core/xds/grpc/xds_listener.h"
 #include "src/core/xds/grpc/xds_route_config.h"
 

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

@@ -0,0 +1,161 @@
+//
+// Copyright 2019 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_server_grpc.h"
+
+#include <stdlib.h>
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/util/json/json_reader.h"
+#include "src/core/util/json/json_writer.h"
+
+namespace grpc_core {
+
+namespace {
+
+constexpr absl::string_view kServerFeatureIgnoreResourceDeletion =
+    "ignore_resource_deletion";
+
+constexpr absl::string_view kServerFeatureTrustedXdsServer =
+    "trusted_xds_server";
+
+}  // namespace
+
+bool GrpcXdsServer::IgnoreResourceDeletion() const {
+  return server_features_.find(std::string(
+             kServerFeatureIgnoreResourceDeletion)) != server_features_.end();
+}
+
+bool GrpcXdsServer::TrustedXdsServer() const {
+  return server_features_.find(std::string(kServerFeatureTrustedXdsServer)) !=
+         server_features_.end();
+}
+
+bool GrpcXdsServer::Equals(const XdsServer& other) const {
+  const auto& o = static_cast<const GrpcXdsServer&>(other);
+  return (server_uri_ == o.server_uri_ &&
+          channel_creds_config_->type() == o.channel_creds_config_->type() &&
+          channel_creds_config_->Equals(*o.channel_creds_config_) &&
+          server_features_ == o.server_features_);
+}
+
+std::string GrpcXdsServer::Key() const { return JsonDump(ToJson()); }
+
+const JsonLoaderInterface* GrpcXdsServer::JsonLoader(const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<GrpcXdsServer>()
+          .Field("server_uri", &GrpcXdsServer::server_uri_)
+          .Finish();
+  return loader;
+}
+
+namespace {
+
+struct ChannelCreds {
+  std::string type;
+  Json::Object config;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<ChannelCreds>()
+            .Field("type", &ChannelCreds::type)
+            .OptionalField("config", &ChannelCreds::config)
+            .Finish();
+    return loader;
+  }
+};
+
+}  // namespace
+
+void GrpcXdsServer::JsonPostLoad(const Json& json, const JsonArgs& args,
+                                 ValidationErrors* errors) {
+  // Parse "channel_creds".
+  auto channel_creds_list = LoadJsonObjectField<std::vector<ChannelCreds>>(
+      json.object(), args, "channel_creds", errors);
+  if (channel_creds_list.has_value()) {
+    ValidationErrors::ScopedField field(errors, ".channel_creds");
+    for (size_t i = 0; i < channel_creds_list->size(); ++i) {
+      ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
+      auto& creds = (*channel_creds_list)[i];
+      // Select the first channel creds type that we support, but
+      // validate all entries.
+      if (CoreConfiguration::Get().channel_creds_registry().IsSupported(
+              creds.type)) {
+        ValidationErrors::ScopedField field(errors, ".config");
+        auto config =
+            CoreConfiguration::Get().channel_creds_registry().ParseConfig(
+                creds.type, Json::FromObject(creds.config), args, errors);
+        if (channel_creds_config_ == nullptr) {
+          channel_creds_config_ = std::move(config);
+        }
+      }
+    }
+    if (channel_creds_config_ == nullptr) {
+      errors->AddError("no known creds type found");
+    }
+  }
+  // Parse "server_features".
+  {
+    ValidationErrors::ScopedField field(errors, ".server_features");
+    auto it = json.object().find("server_features");
+    if (it != json.object().end()) {
+      if (it->second.type() != Json::Type::kArray) {
+        errors->AddError("is not an array");
+      } else {
+        const Json::Array& array = it->second.array();
+        for (const Json& feature_json : array) {
+          if (feature_json.type() == Json::Type::kString &&
+              (feature_json.string() == kServerFeatureIgnoreResourceDeletion ||
+               feature_json.string() == kServerFeatureTrustedXdsServer)) {
+            server_features_.insert(feature_json.string());
+          }
+        }
+      }
+    }
+  }
+}
+
+Json GrpcXdsServer::ToJson() const {
+  Json::Object channel_creds_json{
+      {"type", Json::FromString(std::string(channel_creds_config_->type()))},
+  };
+  if (channel_creds_config_ != nullptr) {
+    channel_creds_json["config"] = channel_creds_config_->ToJson();
+  }
+  Json::Object json{
+      {"server_uri", Json::FromString(server_uri_)},
+      {"channel_creds",
+       Json::FromArray({Json::FromObject(std::move(channel_creds_json))})},
+  };
+  if (!server_features_.empty()) {
+    Json::Array server_features_json;
+    for (auto& feature : server_features_) {
+      server_features_json.emplace_back(Json::FromString(feature));
+    }
+    json["server_features"] = Json::FromArray(std::move(server_features_json));
+  }
+  return Json::FromObject(std::move(json));
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,63 @@
+//
+// Copyright 2019 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_SERVER_GRPC_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_SERVER_GRPC_H
+
+#include <set>
+#include <string>
+
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/security/credentials/channel_creds_registry.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/xds/xds_client/xds_bootstrap.h"
+
+namespace grpc_core {
+
+class GrpcXdsServer final : public XdsBootstrap::XdsServer {
+ public:
+  const std::string& server_uri() const override { return server_uri_; }
+
+  bool IgnoreResourceDeletion() const override;
+
+  bool TrustedXdsServer() const;
+
+  bool Equals(const XdsServer& other) const override;
+
+  std::string Key() const override;
+
+  RefCountedPtr<ChannelCredsConfig> channel_creds_config() const {
+    return channel_creds_config_;
+  }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs& args,
+                    ValidationErrors* errors);
+
+  Json ToJson() const;
+
+ private:
+  std::string server_uri_;
+  RefCountedPtr<ChannelCredsConfig> channel_creds_config_;
+  std::set<std::string> server_features_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_SERVER_GRPC_H

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

@@ -253,8 +253,8 @@ class GrpcXdsTransportFactory::GrpcXdsTransport::StateWatcher final
 
 namespace {
 
-RefCountedPtr<Channel> CreateXdsChannel(
-    const ChannelArgs& args, const GrpcXdsBootstrap::GrpcXdsServer& server) {
+RefCountedPtr<Channel> CreateXdsChannel(const ChannelArgs& args,
+                                        const GrpcXdsServer& server) {
   RefCountedPtr<grpc_channel_credentials> channel_creds =
       CoreConfiguration::Get().channel_creds_registry().CreateChannelCreds(
           server.channel_creds_config());
@@ -269,9 +269,8 @@ GrpcXdsTransportFactory::GrpcXdsTransport::GrpcXdsTransport(
     std::function<void(absl::Status)> on_connectivity_failure,
     absl::Status* status)
     : factory_(factory) {
-  channel_ = CreateXdsChannel(
-      factory->args_,
-      static_cast<const GrpcXdsBootstrap::GrpcXdsServer&>(server));
+  channel_ = CreateXdsChannel(factory->args_,
+                              static_cast<const GrpcXdsServer&>(server));
   CHECK(channel_ != nullptr);
   if (channel_->IsLame()) {
     *status = absl::UnavailableError("xds client has a lame channel");

data/src/core/xds/xds_client/xds_api.cc

@@ -23,6 +23,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 #include "envoy/config/core/v3/base.upb.h"
@@ -43,12 +44,11 @@
 #include "upb/text/encode.h"
 
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/util/json/json.h"
-#include "src/core/xds/grpc/upb_utils.h"
+#include "src/core/util/upb_utils.h"
 #include "src/core/xds/xds_client/xds_client.h"
 
 // IWYU pragma: no_include "upb/msg_internal.h"
@@ -136,8 +136,8 @@ void MaybeLogDiscoveryRequest(
     char buf[10240];
     upb_TextEncode(reinterpret_cast<const upb_Message*>(request), msg_type,
                    nullptr, 0, buf, sizeof(buf));
-    gpr_log(GPR_DEBUG, "[xds_client %p] constructed ADS request: %s",
-            context.client, buf);
+    VLOG(2) << "[xds_client " << context.client
+            << "] constructed ADS request: " << buf;
   }
 }
 
@@ -268,8 +268,8 @@ void MaybeLogDiscoveryResponse(
     char buf[10240];
     upb_TextEncode(reinterpret_cast<const upb_Message*>(response), msg_type,
                    nullptr, 0, buf, sizeof(buf));
-    gpr_log(GPR_DEBUG, "[xds_client %p] received response: %s", context.client,
-            buf);
+    VLOG(2) << "[xds_client " << context.client
+            << "] received response: " << buf;
   }
 }
 
@@ -356,8 +356,8 @@ void MaybeLogLrsRequest(
     char buf[10240];
     upb_TextEncode(reinterpret_cast<const upb_Message*>(request), msg_type,
                    nullptr, 0, buf, sizeof(buf));
-    gpr_log(GPR_DEBUG, "[xds_client %p] constructed LRS request: %s",
-            context.client, buf);
+    VLOG(2) << "[xds_client " << context.client
+            << "] constructed LRS request: " << buf;
   }
 }
 
@@ -517,8 +517,8 @@ void MaybeLogLrsResponse(
     char buf[10240];
     upb_TextEncode(reinterpret_cast<const upb_Message*>(response), msg_type,
                    nullptr, 0, buf, sizeof(buf));
-    gpr_log(GPR_DEBUG, "[xds_client %p] received LRS response: %s",
-            context.client, buf);
+    VLOG(2) << "[xds_client " << context.client
+            << "] received LRS response: " << buf;
   }
 }