grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

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

@@ -18,11 +18,16 @@
 
 #include "src/core/ext/xds/xds_api.h"
 
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "absl/strings/str_cat.h"
+#include "absl/strings/strip.h"
 #include "envoy/admin/v3/config_dump.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/endpoint/v3/load_report.upb.h"
@@ -31,34 +36,27 @@
 #include "envoy/service/load_stats/v3/lrs.upb.h"
 #include "envoy/service/load_stats/v3/lrs.upbdefs.h"
 #include "envoy/service/status/v3/csds.upb.h"
-#include "envoy/service/status/v3/csds.upbdefs.h"
 #include "google/protobuf/any.upb.h"
+#include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
 #include "google/protobuf/timestamp.upb.h"
-#include "google/protobuf/wrappers.upb.h"
 #include "google/rpc/status.upb.h"
+#include "upb/def.h"
 #include "upb/text_encode.h"
 #include "upb/upb.h"
 #include "upb/upb.hpp"
 
-#include <grpc/impl/codegen/log.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
-#include "src/core/ext/xds/xds_common_types.h"
-#include "src/core/ext/xds/xds_resource_type.h"
-#include "src/core/ext/xds/xds_routing.h"
-#include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/host_port.h"
+#include "src/core/ext/xds/xds_client.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/socket_utils.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/uri/uri_parser.h"
+#include "src/core/lib/json/json.h"
+
+// IWYU pragma: no_include "upb/msg_internal.h"
 
 namespace grpc_core {
 
@@ -303,7 +301,7 @@ grpc_slice XdsApi::CreateAdsRequest(
   }
   // Set error_detail if it's a NACK.
   std::string error_string_storage;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     google_rpc_Status* error_detail =
         envoy_service_discovery_v3_DiscoveryRequest_mutable_error_detail(
             request, arena.ptr());

data/src/core/ext/xds/xds_api.h

@@ -19,22 +19,29 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
+#include <stddef.h>
 
+#include <map>
 #include <set>
+#include <string>
+#include <utility>
+#include <vector>
 
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 #include "envoy/admin/v3/config_dump.upb.h"
 #include "upb/def.hpp"
 
 #include <grpc/slice.h>
 
+#include "src/core/ext/xds/certificate_provider_store.h"
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_client_stats.h"
-#include "src/core/ext/xds/xds_http_filters.h"
-#include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/matchers/matchers.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
 
 namespace grpc_core {
 

data/src/core/ext/xds/xds_bootstrap.cc

@@ -18,29 +18,28 @@
 
 #include "src/core/ext/xds/xds_bootstrap.h"
 
-#include <errno.h>
 #include <stdlib.h>
 
+#include <utility>
 #include <vector>
 
+#include "absl/memory/memory.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
 
+#include "src/core/ext/xds/certificate_provider_factory.h"
 #include "src/core/ext/xds/certificate_provider_registry.h"
-#include "src/core/ext/xds/xds_api.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/load_file.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/json/json_util.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
-#include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/security/credentials/fake/fake_credentials.h"
-#include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {
 
@@ -56,6 +55,10 @@ bool XdsFederationEnabled() {
 
 namespace {
 
+const absl::string_view kServerFeatureXdsV3 = "xds_v3";
+const absl::string_view kServerFeatureIgnoreResourceDeletion =
+    "ignore_resource_deletion";
+
 grpc_error_handle ParseChannelCreds(const Json::Object& json, size_t idx,
                                     XdsBootstrap::XdsServer* server) {
   std::vector<grpc_error_handle> error_list;
@@ -92,7 +95,7 @@ grpc_error_handle ParseChannelCredsArray(const Json::Array& json,
     } else {
       grpc_error_handle parse_error =
           ParseChannelCreds(child.object_value(), i, server);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   if (server->channel_creds_type.empty()) {
@@ -121,7 +124,7 @@ XdsBootstrap::XdsServer XdsBootstrap::XdsServer::Parse(
   if (creds_array != nullptr) {
     grpc_error_handle parse_error =
         ParseChannelCredsArray(*creds_array, &server);
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
   }
   const Json::Array* server_features_array = nullptr;
   ParseJsonObjectField(json.object_value(), "server_features",
@@ -129,7 +132,9 @@ XdsBootstrap::XdsServer XdsBootstrap::XdsServer::Parse(
   if (server_features_array != nullptr) {
     for (const Json& feature_json : *server_features_array) {
       if (feature_json.type() == Json::Type::STRING &&
-          feature_json.string_value() == "xds_v3") {
+          (feature_json.string_value() == kServerFeatureXdsV3 ||
+           feature_json.string_value() ==
+               kServerFeatureIgnoreResourceDeletion)) {
         server.server_features.insert(feature_json.string_value());
       }
     }
@@ -159,7 +164,13 @@ Json::Object XdsBootstrap::XdsServer::ToJson() const {
 }
 
 bool XdsBootstrap::XdsServer::ShouldUseV3() const {
-  return server_features.find("xds_v3") != server_features.end();
+  return server_features.find(std::string(kServerFeatureXdsV3)) !=
+         server_features.end();
+}
+
+bool XdsBootstrap::XdsServer::IgnoreResourceDeletion() const {
+  return server_features.find(std::string(
+             kServerFeatureIgnoreResourceDeletion)) != server_features.end();
 }
 
 //
@@ -169,7 +180,7 @@ bool XdsBootstrap::XdsServer::ShouldUseV3() const {
 std::unique_ptr<XdsBootstrap> XdsBootstrap::Create(
     absl::string_view json_string, grpc_error_handle* error) {
   Json json = Json::Parse(json_string, error);
-  if (*error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(*error)) {
     grpc_error_handle error_out =
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "Failed to parse bootstrap JSON string", error, 1);
@@ -196,7 +207,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
         "\"xds_servers\" field is not an array"));
   } else {
     grpc_error_handle parse_error = ParseXdsServerList(&it->second, &servers_);
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
   }
   it = json.mutable_object()->find("node");
   if (it != json.mutable_object()->end()) {
@@ -205,7 +216,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
           "\"node\" field is not an object"));
     } else {
       grpc_error_handle parse_error = ParseNode(&it->second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   if (XdsFederationEnabled()) {
@@ -216,7 +227,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
             "\"authorities\" field is not an object"));
       } else {
         grpc_error_handle parse_error = ParseAuthorities(&it->second);
-        if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+        if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
       }
     }
     it = json.mutable_object()->find(
@@ -249,7 +260,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
           "\"certificate_providers\" field is not an object"));
     } else {
       grpc_error_handle parse_error = ParseCertificateProviders(&it->second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing xds bootstrap file",
@@ -277,7 +288,7 @@ bool XdsBootstrap::XdsServerExists(
 }
 
 grpc_error_handle XdsBootstrap::ParseXdsServerList(
-    Json* json, absl::InlinedVector<XdsServer, 1>* servers) {
+    Json* json, std::vector<XdsServer>* servers) {
   std::vector<grpc_error_handle> error_list;
   for (size_t i = 0; i < json->mutable_array()->size(); ++i) {
     Json& child = json->mutable_array()->at(i);
@@ -287,7 +298,7 @@ grpc_error_handle XdsBootstrap::ParseXdsServerList(
     } else {
       grpc_error_handle parse_error;
       servers->emplace_back(XdsServer::Parse(child, &parse_error));
-      if (parse_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(parse_error)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
             absl::StrCat("errors parsing index ", i)));
         error_list.push_back(parse_error);
@@ -307,7 +318,7 @@ grpc_error_handle XdsBootstrap::ParseAuthorities(Json* json) {
       continue;
     }
     grpc_error_handle parse_error = ParseAuthority(&p.second, p.first);
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"authorities\"",
                                        &error_list);
@@ -344,7 +355,7 @@ grpc_error_handle XdsBootstrap::ParseAuthority(Json* json,
     } else {
       grpc_error_handle parse_error =
           ParseXdsServerList(&it->second, &authority.xds_servers);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   if (error_list.empty()) {
@@ -382,7 +393,7 @@ grpc_error_handle XdsBootstrap::ParseNode(Json* json) {
           "\"locality\" field is not an object"));
     } else {
       grpc_error_handle parse_error = ParseLocality(&it->second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   it = json->mutable_object()->find("metadata");
@@ -440,7 +451,7 @@ grpc_error_handle XdsBootstrap::ParseCertificateProviders(Json* json) {
     } else {
       grpc_error_handle parse_error = ParseCertificateProvider(
           certificate_provider.first, &certificate_provider.second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR(
@@ -476,14 +487,16 @@ grpc_error_handle XdsBootstrap::ParseCertificateProvider(
           grpc_error_handle parse_error = GRPC_ERROR_NONE;
           config = factory->CreateCertificateProviderConfig(it->second,
                                                             &parse_error);
-          if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+          if (!GRPC_ERROR_IS_NONE(parse_error)) {
+            error_list.push_back(parse_error);
+          }
         }
       } else {
         // "config" is an optional field, so create an empty JSON object.
         grpc_error_handle parse_error = GRPC_ERROR_NONE;
         config = factory->CreateCertificateProviderConfig(Json::Object(),
                                                           &parse_error);
-        if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+        if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
       }
       certificate_providers_.insert(
           {instance_name, {std::move(plugin_name), std::move(config)}});

data/src/core/ext/xds/xds_bootstrap.h

@@ -19,21 +19,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
+#include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "absl/container/inlined_vector.h"
-
-#include <grpc/slice.h>
+#include "absl/strings/string_view.h"
 
 #include "src/core/ext/xds/certificate_provider_store.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/security/credentials/credentials.h"
 
 namespace grpc_core {
 
@@ -80,11 +77,12 @@ class XdsBootstrap {
     Json::Object ToJson() const;
 
     bool ShouldUseV3() const;
+    bool IgnoreResourceDeletion() const;
   };
 
   struct Authority {
     std::string client_listener_resource_name_template;
-    absl::InlinedVector<XdsServer, 1> xds_servers;
+    std::vector<XdsServer> xds_servers;
   };
 
   // Creates bootstrap object from json_string.
@@ -120,8 +118,8 @@ class XdsBootstrap {
   bool XdsServerExists(const XdsServer& server) const;
 
  private:
-  grpc_error_handle ParseXdsServerList(
-      Json* json, absl::InlinedVector<XdsServer, 1>* servers);
+  grpc_error_handle ParseXdsServerList(Json* json,
+                                       std::vector<XdsServer>* servers);
   grpc_error_handle ParseAuthorities(Json* json);
   grpc_error_handle ParseAuthority(Json* json, const std::string& name);
   grpc_error_handle ParseNode(Json* json);
@@ -130,7 +128,7 @@ class XdsBootstrap {
   grpc_error_handle ParseCertificateProvider(const std::string& instance_name,
                                              Json* certificate_provider_json);
 
-  absl::InlinedVector<XdsServer, 1> servers_;
+  std::vector<XdsServer> servers_;
   std::unique_ptr<Node> node_;
   std::string client_default_listener_resource_name_template_;
   std::string server_listener_resource_name_template_;
@@ -140,4 +138,4 @@ class XdsBootstrap {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H */
+#endif  // GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H

data/src/core/ext/xds/xds_certificate_provider.cc

@@ -20,8 +20,17 @@
 
 #include "src/core/ext/xds/xds_certificate_provider.h"
 
+#include <utility>
+
 #include "absl/functional/bind_front.h"
-#include "absl/strings/str_cat.h"
+#include "absl/memory/memory.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/security/security_connector/ssl_utils.h"
 
 namespace grpc_core {
 
@@ -51,7 +60,7 @@ class RootCertificatesWatcher
 
   void OnError(grpc_error_handle root_cert_error,
                grpc_error_handle identity_cert_error) override {
-    if (root_cert_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(root_cert_error)) {
       parent_->SetErrorForCert(cert_name_, root_cert_error /* pass the ref */,
                                absl::nullopt);
     }
@@ -86,7 +95,7 @@ class IdentityCertificatesWatcher
 
   void OnError(grpc_error_handle root_cert_error,
                grpc_error_handle identity_cert_error) override {
-    if (identity_cert_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(identity_cert_error)) {
       parent_->SetErrorForCert(cert_name_, absl::nullopt,
                                identity_cert_error /* pass the ref */);
     }
@@ -263,7 +272,10 @@ XdsCertificateProvider::~XdsCertificateProvider() {
   distributor_->SetWatchStatusCallback(nullptr);
 }
 
-const char* XdsCertificateProvider::type() const { return "Xds"; }
+UniqueTypeName XdsCertificateProvider::type() const {
+  static UniqueTypeName::Factory kFactory("Xds");
+  return kFactory.Create();
+}
 
 bool XdsCertificateProvider::ProvidesRootCerts(const std::string& cert_name) {
   MutexLock lock(&mu_);

data/src/core/ext/xds/xds_certificate_provider.h

@@ -21,8 +21,23 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/xds_api.h"
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/matchers/matchers.h"
+#include "src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 #define GRPC_ARG_XDS_CERTIFICATE_PROVIDER \
@@ -39,7 +54,7 @@ class XdsCertificateProvider : public grpc_tls_certificate_provider {
     return distributor_;
   }
 
-  const char* type() const override;
+  UniqueTypeName type() const override;
 
   bool ProvidesRootCerts(const std::string& cert_name);
   void UpdateRootCertNameAndDistributor(

data/src/core/ext/xds/xds_channel_stack_modifier.cc

@@ -20,8 +20,17 @@
 
 #include "src/core/ext/xds/xds_channel_stack_modifier.h"
 
+#include <limits.h>
+#include <string.h>
+
+#include <algorithm>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 
 namespace grpc_core {
 namespace {
@@ -53,7 +62,7 @@ bool XdsChannelStackModifier::ModifyChannelStack(ChannelStackBuilder* builder) {
   // Insert the filters after the census filter if present.
   auto it = builder->mutable_stack()->begin();
   while (it != builder->mutable_stack()->end()) {
-    const char* filter_name_at_it = it->filter->name;
+    const char* filter_name_at_it = (*it)->name;
     if (strcmp("census_server", filter_name_at_it) == 0 ||
         strcmp("opencensus_server", filter_name_at_it) == 0) {
       break;
@@ -71,8 +80,7 @@ bool XdsChannelStackModifier::ModifyChannelStack(ChannelStackBuilder* builder) {
     ++it;
   }
   for (const grpc_channel_filter* filter : filters_) {
-    it = builder->mutable_stack()->insert(
-        it, ChannelStackBuilder::StackEntry{filter, nullptr});
+    it = builder->mutable_stack()->insert(it, filter);
     ++it;
   }
   return true;
@@ -96,9 +104,10 @@ XdsChannelStackModifier::GetFromChannelArgs(const grpc_channel_args& args) {
 void RegisterXdsChannelStackModifier(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(
       GRPC_SERVER_CHANNEL, INT_MAX, [](ChannelStackBuilder* builder) {
+        const grpc_channel_args* channel_args = builder->channel_args().ToC();
         RefCountedPtr<XdsChannelStackModifier> channel_stack_modifier =
-            XdsChannelStackModifier::GetFromChannelArgs(
-                *builder->channel_args());
+            XdsChannelStackModifier::GetFromChannelArgs(*channel_args);
+        grpc_channel_args_destroy(channel_args);
         if (channel_stack_modifier != nullptr) {
           return channel_stack_modifier->ModifyChannelStack(builder);
         }

data/src/core/ext/xds/xds_channel_stack_modifier.h

@@ -21,11 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <utility>
 #include <vector>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {