grpc 1.70.1 → 1.71.0

data/src/core/resolver/google_c2p/google_c2p_resolver.cc

@@ -19,6 +19,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <random>
 #include <string>
 #include <type_traits>
@@ -30,7 +31,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/polling_entity.h"
@@ -81,10 +81,10 @@ class GoogleCloud2ProdResolver final : public Resolver {
   bool shutdown_ = false;
 
   OrphanablePtr<GcpMetadataQuery> zone_query_;
-  absl::optional<std::string> zone_;
+  std::optional<std::string> zone_;
 
   OrphanablePtr<GcpMetadataQuery> ipv6_query_;
-  absl::optional<bool> supports_ipv6_;
+  std::optional<bool> supports_ipv6_;
 };
 
 //
@@ -126,7 +126,7 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
     return;
   }
   // Maybe override metadata server name for testing
-  absl::optional<std::string> test_only_metadata_server_override =
+  std::optional<std::string> test_only_metadata_server_override =
       args.args.GetOwnedString(
           "grpc.testing.google_c2p_resolver_metadata_server_override");
   if (test_only_metadata_server_override.has_value() &&
@@ -156,12 +156,10 @@ void GoogleCloud2ProdResolver::StartLocked() {
       [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
           std::string /* attribute */,
           absl::StatusOr<std::string> result) mutable {
-        resolver->work_serializer_->Run(
-            [resolver, result = std::move(result)]() mutable {
-              resolver->ZoneQueryDone(result.ok() ? std::move(result).value()
-                                                  : "");
-            },
-            DEBUG_LOCATION);
+        resolver->work_serializer_->Run([resolver,
+                                         result = std::move(result)]() mutable {
+          resolver->ZoneQueryDone(result.ok() ? std::move(result).value() : "");
+        });
       },
       Duration::Seconds(10));
   ipv6_query_ = MakeOrphanable<GcpMetadataQuery>(
@@ -177,8 +175,7 @@ void GoogleCloud2ProdResolver::StartLocked() {
               // servers in the wild, which can in some cases return 200
               // plus an empty result when they should have returned 404.
               resolver->IPv6QueryDone(result.ok() && !result->empty());
-            },
-            DEBUG_LOCATION);
+            });
       },
       Duration::Seconds(10));
 }

data/src/core/resolver/polling_resolver.cc

@@ -106,12 +106,10 @@ void PollingResolver::ScheduleNextResolutionTimer(Duration delay) {
   next_resolution_timer_handle_ =
       channel_args_.GetObject<EventEngine>()->RunAfter(
           delay, [self = RefAsSubclass<PollingResolver>()]() mutable {
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto* self_ptr = self.get();
             self_ptr->work_serializer_->Run(
-                [self = std::move(self)]() { self->OnNextResolutionLocked(); },
-                DEBUG_LOCATION);
+                [self = std::move(self)]() { self->OnNextResolutionLocked(); });
           });
 }
 
@@ -142,8 +140,7 @@ void PollingResolver::MaybeCancelNextResolutionTimer() {
 void PollingResolver::OnRequestComplete(Result result) {
   Ref(DEBUG_LOCATION, "OnRequestComplete").release();
   work_serializer_->Run(
-      [this, result]() mutable { OnRequestCompleteLocked(std::move(result)); },
-      DEBUG_LOCATION);
+      [this, result]() mutable { OnRequestCompleteLocked(std::move(result)); });
 }
 
 void PollingResolver::OnRequestCompleteLocked(Result result) {

data/src/core/resolver/polling_resolver.h

@@ -21,10 +21,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -98,7 +98,7 @@ class PollingResolver : public Resolver {
   /// min time between DNS requests
   Duration min_time_between_resolutions_;
   /// timestamp of last DNS request
-  absl::optional<Timestamp> last_resolution_timestamp_;
+  std::optional<Timestamp> last_resolution_timestamp_;
   /// retry backoff state
   BackOff backoff_;
   /// state for handling interactions between re-resolution requests and
@@ -110,7 +110,7 @@ class PollingResolver : public Resolver {
   };
   ResultStatusState result_status_state_ = ResultStatusState::kNone;
   /// next resolution timer
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       next_resolution_timer_handle_;
 };
 

data/src/core/resolver/resolver_registry.cc

@@ -51,9 +51,10 @@ bool IsLowerCase(absl::string_view str) {
 
 void ResolverRegistry::Builder::RegisterResolverFactory(
     std::unique_ptr<ResolverFactory> factory) {
-  CHECK(IsLowerCase(factory->scheme()));
-  auto p = state_.factories.emplace(factory->scheme(), std::move(factory));
-  CHECK(p.second);
+  CHECK(IsLowerCase(factory->scheme())) << factory->scheme();
+  auto [_, inserted] =
+      state_.factories.try_emplace(factory->scheme(), std::move(factory));
+  CHECK(inserted) << "scheme " << factory->scheme() << " already registered";
 }
 
 bool ResolverRegistry::Builder::HasResolverFactory(

data/src/core/resolver/xds/xds_config.cc

@@ -56,18 +56,18 @@ std::string XdsConfig::ToString() const {
       "}\n  route_config: {", route_config->ToString(),
       "}\n  virtual_host: {", virtual_host->ToString(),
       "}\n  clusters: {\n"};
-  for (const auto& p : clusters) {
-    parts.push_back(absl::StrCat("    \"", p.first, "\": "));
-    if (!p.second.ok()) {
-      parts.push_back(p.second.status().ToString());
+  for (const auto& [name, cluster_config] : clusters) {
+    parts.push_back(absl::StrCat("    \"", name, "\": "));
+    if (!cluster_config.ok()) {
+      parts.push_back(cluster_config.status().ToString());
       parts.push_back("\n");
     } else {
       parts.push_back(
           absl::StrCat("      {\n"
                        "        cluster: {",
-                       p.second->cluster->ToString(), "}\n"));
+                       cluster_config->cluster->ToString(), "}\n"));
       Match(
-          p.second->children,
+          cluster_config->children,
           [&](const ClusterConfig::EndpointConfig& endpoint_config) {
             parts.push_back(
                 absl::StrCat("        endpoints: {",

data/src/core/resolver/xds/xds_config.h

@@ -20,12 +20,12 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/xds/grpc/xds_cluster.h"
 #include "src/core/xds/grpc/xds_endpoint.h"
@@ -73,7 +73,7 @@ struct XdsConfig : public RefCounted<XdsConfig> {
         return leaf_clusters == other.leaf_clusters;
       }
     };
-    absl::variant<EndpointConfig, AggregateConfig> children;
+    std::variant<EndpointConfig, AggregateConfig> children;
 
     // Ctor for leaf clusters.
     ClusterConfig(std::shared_ptr<const XdsClusterResource> cluster,

data/src/core/resolver/xds/xds_dependency_manager.cc

@@ -68,8 +68,7 @@ class XdsDependencyManager::ListenerWatcher final
         [dependency_mgr = dependency_mgr_, status = std::move(status),
          read_delay_handle = std::move(read_delay_handle)]() mutable {
           dependency_mgr->OnListenerAmbientError(std::move(status));
-        },
-        DEBUG_LOCATION);
+        });
   }
 
  private:
@@ -97,8 +96,7 @@ class XdsDependencyManager::RouteConfigWatcher final
          read_delay_handle = std::move(read_delay_handle)]() mutable {
           self->dependency_mgr_->OnRouteConfigUpdate(self->name_,
                                                      std::move(route_config));
-        },
-        DEBUG_LOCATION);
+        });
   }
 
   void OnAmbientError(
@@ -109,8 +107,7 @@ class XdsDependencyManager::RouteConfigWatcher final
          read_delay_handle = std::move(read_delay_handle)]() mutable {
           self->dependency_mgr_->OnRouteConfigAmbientError(self->name_,
                                                            std::move(status));
-        },
-        DEBUG_LOCATION);
+        });
   }
 
  private:
@@ -137,8 +134,7 @@ class XdsDependencyManager::ClusterWatcher final
          read_delay_handle = std::move(read_delay_handle)]() mutable {
           self->dependency_mgr_->OnClusterUpdate(self->name_,
                                                  std::move(cluster));
-        },
-        DEBUG_LOCATION);
+        });
   }
 
   void OnAmbientError(
@@ -149,8 +145,7 @@ class XdsDependencyManager::ClusterWatcher final
          read_delay_handle = std::move(read_delay_handle)]() mutable {
           self->dependency_mgr_->OnClusterAmbientError(self->name_,
                                                        std::move(status));
-        },
-        DEBUG_LOCATION);
+        });
   }
 
  private:
@@ -190,8 +185,7 @@ class XdsDependencyManager::EndpointWatcher final
          read_delay_handle = std::move(read_delay_handle)]() mutable {
           self->dependency_mgr_->OnEndpointAmbientError(self->name_,
                                                         std::move(status));
-        },
-        DEBUG_LOCATION);
+        });
   }
 
  private:
@@ -215,8 +209,7 @@ class XdsDependencyManager::DnsResultHandler final
         [dependency_mgr = dependency_mgr_, name = name_,
          result = std::move(result)]() mutable {
           dependency_mgr->OnDnsResult(name, std::move(result));
-        },
-        DEBUG_LOCATION);
+        });
   }
 
  private:
@@ -229,12 +222,10 @@ class XdsDependencyManager::DnsResultHandler final
 //
 
 void XdsDependencyManager::ClusterSubscription::Orphaned() {
-  dependency_mgr_->work_serializer_->Run(
-      [self = WeakRef()]() {
-        self->dependency_mgr_->OnClusterSubscriptionUnref(self->cluster_name_,
-                                                          self.get());
-      },
-      DEBUG_LOCATION);
+  dependency_mgr_->work_serializer_->Run([self = WeakRef()]() {
+    self->dependency_mgr_->OnClusterSubscriptionUnref(self->cluster_name_,
+                                                      self.get());
+  });
 }
 
 //
@@ -276,33 +267,33 @@ void XdsDependencyManager::Orphan() {
         xds_client_.get(), route_config_name_, route_config_watcher_,
         /*delay_unsubscription=*/false);
   }
-  for (const auto& p : cluster_watchers_) {
-    XdsClusterResourceType::CancelWatch(xds_client_.get(), p.first,
-                                        p.second.watcher,
+  for (const auto& [name, cluster_state] : cluster_watchers_) {
+    XdsClusterResourceType::CancelWatch(xds_client_.get(), name,
+                                        cluster_state.watcher,
                                         /*delay_unsubscription=*/false);
   }
-  for (const auto& p : endpoint_watchers_) {
-    XdsEndpointResourceType::CancelWatch(xds_client_.get(), p.first,
-                                         p.second.watcher,
+  for (const auto& [name, endpoint_state] : endpoint_watchers_) {
+    XdsEndpointResourceType::CancelWatch(xds_client_.get(), name,
+                                         endpoint_state.watcher,
                                          /*delay_unsubscription=*/false);
   }
   cluster_subscriptions_.clear();
   xds_client_.reset();
-  for (auto& p : dns_resolvers_) {
-    p.second.resolver.reset();
+  for (auto& [_, dns_state] : dns_resolvers_) {
+    dns_state.resolver.reset();
   }
   Unref();
 }
 
 void XdsDependencyManager::RequestReresolution() {
-  for (const auto& p : dns_resolvers_) {
-    p.second.resolver->RequestReresolutionLocked();
+  for (const auto& [_, dns_state] : dns_resolvers_) {
+    dns_state.resolver->RequestReresolutionLocked();
   }
 }
 
 void XdsDependencyManager::ResetBackoff() {
-  for (const auto& p : dns_resolvers_) {
-    p.second.resolver->ResetBackoffLocked();
+  for (const auto& [_, dns_state] : dns_resolvers_) {
+    dns_state.resolver->ResetBackoffLocked();
   }
 }
 
@@ -316,7 +307,7 @@ void XdsDependencyManager::OnListenerUpdate(
     return ReportError("LDS", listener_resource_name_,
                        listener.status().message());
   }
-  const auto* hcm = absl::get_if<XdsListenerResource::HttpConnectionManager>(
+  const auto* hcm = std::get_if<XdsListenerResource::HttpConnectionManager>(
       &(*listener)->listener);
   if (hcm == nullptr) {
     current_listener_.reset();
@@ -415,7 +406,7 @@ absl::flat_hash_set<absl::string_view> GetClustersFromVirtualHost(
   absl::flat_hash_set<absl::string_view> clusters;
   for (auto& route : virtual_host.routes) {
     auto* route_action =
-        absl::get_if<XdsRouteConfigResource::Route::RouteAction>(&route.action);
+        std::get_if<XdsRouteConfigResource::Route::RouteAction>(&route.action);
     if (route_action == nullptr) continue;
     Match(
         route_action->action,
@@ -527,10 +518,11 @@ void XdsDependencyManager::OnClusterAmbientError(const std::string& name,
   if (xds_client_ == nullptr) return;
   auto it = cluster_watchers_.find(name);
   if (it == cluster_watchers_.end()) return;
+  auto& cluster_watcher = it->second;
   if (status.ok()) {
-    it->second.resolution_note.clear();
+    cluster_watcher.resolution_note.clear();
   } else {
-    it->second.resolution_note =
+    cluster_watcher.resolution_note =
         absl::StrCat("CDS resource ", name, ": ", status.message());
   }
   MaybeReportUpdate();
@@ -544,33 +536,34 @@ void XdsDependencyManager::OnEndpointUpdate(
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
   if (it == endpoint_watchers_.end()) return;
+  auto& endpoint_watcher = it->second;
   if (!endpoint.ok()) {
-    it->second.update.endpoints.reset();
-    it->second.update.resolution_note =
+    endpoint_watcher.update.endpoints.reset();
+    endpoint_watcher.update.resolution_note =
         absl::StrCat("EDS resource ", name, ": ", endpoint.status().message());
   } else {
     if ((*endpoint)->priorities.empty()) {
-      it->second.update.resolution_note =
+      endpoint_watcher.update.resolution_note =
           absl::StrCat("EDS resource ", name, ": contains no localities");
     } else {
       std::set<absl::string_view> empty_localities;
       for (const auto& priority : (*endpoint)->priorities) {
-        for (const auto& p : priority.localities) {
-          if (p.second.endpoints.empty()) {
+        for (const auto& [name, locality] : priority.localities) {
+          if (locality.endpoints.empty()) {
             empty_localities.insert(
-                p.first->human_readable_string().as_string_view());
+                name->human_readable_string().as_string_view());
           }
         }
       }
       if (!empty_localities.empty()) {
-        it->second.update.resolution_note = absl::StrCat(
+        endpoint_watcher.update.resolution_note = absl::StrCat(
             "EDS resource ", name, ": contains empty localities: [",
             absl::StrJoin(empty_localities, "; "), "]");
       } else {
-        it->second.update.resolution_note.clear();
+        endpoint_watcher.update.resolution_note.clear();
       }
     }
-    it->second.update.endpoints = std::move(*endpoint);
+    endpoint_watcher.update.endpoints = std::move(*endpoint);
   }
   MaybeReportUpdate();
 }
@@ -583,10 +576,11 @@ void XdsDependencyManager::OnEndpointAmbientError(const std::string& name,
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
   if (it == endpoint_watchers_.end()) return;
+  auto& endpoint_watcher = it->second;
   if (status.ok()) {
-    it->second.update.resolution_note.clear();
+    endpoint_watcher.update.resolution_note.clear();
   } else {
-    it->second.update.resolution_note =
+    endpoint_watcher.update.resolution_note =
         absl::StrCat("EDS resource ", name, ": ", status.message());
   }
   MaybeReportUpdate();
@@ -629,6 +623,28 @@ void XdsDependencyManager::PopulateDnsUpdate(const std::string& dns_name,
   dns_state->update.endpoints = std::move(resource);
 }
 
+std::string XdsDependencyManager::GenerateResolutionNoteForCluster(
+    absl::string_view cluster_resolution_note,
+    absl::string_view endpoint_resolution_note) const {
+  std::array<absl::string_view, 4> notes = {
+      lds_resolution_note_, rds_resolution_note_, cluster_resolution_note,
+      endpoint_resolution_note};
+  std::vector<absl::string_view> resolution_notes;
+  for (const auto& note : notes) {
+    if (!note.empty()) resolution_notes.push_back(note);
+  }
+  std::string node_id_buffer;
+  if (resolution_notes.empty()) {
+    const XdsBootstrap::Node* node =
+        DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap()).node();
+    if (node != nullptr) {
+      node_id_buffer = absl::StrCat("xDS node ID:", node->id());
+      resolution_notes.push_back(node_id_buffer);
+    }
+  }
+  return absl::StrJoin(resolution_notes, "; ");
+}
+
 bool XdsDependencyManager::PopulateClusterConfigMap(
     absl::string_view name, int depth,
     absl::flat_hash_map<std::string, absl::StatusOr<XdsConfig::ClusterConfig>>*
@@ -647,10 +663,10 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
   // status here, since we need an entry in the map to avoid incorrectly
   // stopping the CDS watch, but we'll overwrite this below if we actually
   // have the data for the cluster.
-  auto p = cluster_config_map->emplace(
+  auto [it, inserted] = cluster_config_map->emplace(
       name, absl::InternalError("cluster data not yet available"));
-  if (!p.second) return true;
-  auto& cluster_config = p.first->second;
+  if (!inserted) return true;
+  auto& cluster_config = it->second;
   auto& state = cluster_watchers_[name];
   // Create a new watcher if needed.
   if (state.watcher == nullptr) {
@@ -697,25 +713,10 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
           return false;
         }
         // Populate cluster config.
-        std::array<absl::string_view, 4> notes = {
-            lds_resolution_note_, rds_resolution_note_, state.resolution_note,
-            eds_state.update.resolution_note};
-        std::vector<absl::string_view> resolution_notes;
-        for (const auto& note : notes) {
-          if (!note.empty()) resolution_notes.push_back(note);
-        }
-        std::string node_id_buffer;
-        if (resolution_notes.empty()) {
-          const XdsBootstrap::Node* node =
-              DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
-                  .node();
-          if (node != nullptr) {
-            node_id_buffer = absl::StrCat("xDS node ID:", node->id());
-            resolution_notes.push_back(node_id_buffer);
-          }
-        }
-        cluster_config.emplace(*state.update, eds_state.update.endpoints,
-                               absl::StrJoin(resolution_notes, "; "));
+        cluster_config.emplace(
+            *state.update, eds_state.update.endpoints,
+            GenerateResolutionNoteForCluster(state.resolution_note,
+                                             eds_state.update.resolution_note));
         if (leaf_clusters != nullptr) (*leaf_clusters)->push_back(name);
         return true;
       },
@@ -762,8 +763,10 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
           return false;
         }
         // Populate cluster config.
-        cluster_config.emplace(*state.update, dns_state.update.endpoints,
-                               dns_state.update.resolution_note);
+        cluster_config.emplace(
+            *state.update, dns_state.update.endpoints,
+            GenerateResolutionNoteForCluster(state.resolution_note,
+                                             dns_state.update.resolution_note));
         if (leaf_clusters != nullptr) (*leaf_clusters)->push_back(name);
         return true;
       },
@@ -870,8 +873,8 @@ void XdsDependencyManager::MaybeReportUpdate() {
   for (const absl::string_view& cluster : clusters_from_route_config_) {
     clusters_to_watch.insert(cluster);
   }
-  for (const auto& p : cluster_subscriptions_) {
-    clusters_to_watch.insert(p.first);
+  for (const auto& [name, _] : cluster_subscriptions_) {
+    clusters_to_watch.insert(name);
   }
   // Populate Cluster map.
   // We traverse the entire graph even if we don't yet have all of the
@@ -886,7 +889,7 @@ void XdsDependencyManager::MaybeReportUpdate() {
   // Remove entries in cluster_watchers_ for any clusters not in
   // config->clusters.
   for (auto it = cluster_watchers_.begin(); it != cluster_watchers_.end();) {
-    const std::string& cluster_name = it->first;
+    auto& [cluster_name, cluster_watcher] = *it;
     if (config->clusters.contains(cluster_name)) {
       ++it;
       continue;
@@ -895,14 +898,14 @@ void XdsDependencyManager::MaybeReportUpdate() {
         << "[XdsDependencyManager " << this << "] cancelling watch for cluster "
         << cluster_name;
     XdsClusterResourceType::CancelWatch(xds_client_.get(), cluster_name,
-                                        it->second.watcher,
+                                        cluster_watcher.watcher,
                                         /*delay_unsubscription=*/false);
     cluster_watchers_.erase(it++);
   }
   // Remove entries in endpoint_watchers_ for any EDS resources not in
   // eds_resources_seen.
   for (auto it = endpoint_watchers_.begin(); it != endpoint_watchers_.end();) {
-    const std::string& eds_resource_name = it->first;
+    auto& [eds_resource_name, endpoint_watcher] = *it;
     if (eds_resources_seen.find(eds_resource_name) !=
         eds_resources_seen.end()) {
       ++it;
@@ -912,7 +915,7 @@ void XdsDependencyManager::MaybeReportUpdate() {
         << "[XdsDependencyManager " << this
         << "] cancelling watch for EDS resource " << eds_resource_name;
     XdsEndpointResourceType::CancelWatch(xds_client_.get(), eds_resource_name,
-                                         it->second.watcher,
+                                         endpoint_watcher.watcher,
                                          /*delay_unsubscription=*/false);
     endpoint_watchers_.erase(it++);
   }

data/src/core/resolver/xds/xds_dependency_manager.h

@@ -152,6 +152,10 @@ class XdsDependencyManager final : public RefCounted<XdsDependencyManager>,
   void PopulateDnsUpdate(const std::string& dns_name, Resolver::Result result,
                          DnsState* dns_state);
 
+  std::string GenerateResolutionNoteForCluster(
+      absl::string_view cluster_resolution_note,
+      absl::string_view endpoint_resolution_note) const;
+
   // Starts CDS and EDS/DNS watches for the specified cluster if needed.
   // Adds an entry to cluster_config_map, which will contain the cluster
   // data if the data is available.