grpc 1.72.0 → 1.74.0.pre2

data/src/core/load_balancing/rls/rls.cc

@@ -97,6 +97,7 @@
 #include "src/core/util/match.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
@@ -1557,7 +1558,7 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
     auto parent_channelz_node =
         lb_policy_->channel_args_.GetObjectRef<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
-      parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
+      child_channelz_node->AddParent(parent_channelz_node.get());
       parent_channelz_node_ = std::move(parent_channelz_node);
     }
     // Start connectivity watch.
@@ -1578,7 +1579,7 @@ void RlsLb::RlsChannel::Orphan() {
     if (parent_channelz_node_ != nullptr) {
       channelz::ChannelNode* child_channelz_node = channel_->channelz_node();
       CHECK_NE(child_channelz_node, nullptr);
-      parent_channelz_node_->RemoveChildChannel(child_channelz_node->uuid());
+      child_channelz_node->RemoveParent(parent_channelz_node_.get());
     }
     // Stop connectivity watch.
     if (watcher_ != nullptr) {
@@ -1852,9 +1853,9 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
 
 std::string GenerateUUID() {
   absl::uniform_int_distribution<uint64_t> distribution;
-  absl::BitGen bitgen;
-  uint64_t hi = distribution(bitgen);
-  uint64_t lo = distribution(bitgen);
+  SharedBitGen g;
+  uint64_t hi = distribution(g);
+  uint64_t lo = distribution(g);
   return GenerateUUIDv4(hi, lo);
 }
 

data/src/core/load_balancing/round_robin/round_robin.cc

@@ -47,6 +47,7 @@
 #include "src/core/util/json/json.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/work_serializer.h"
 
 namespace grpc_core {
@@ -166,8 +167,6 @@ class RoundRobin final : public LoadBalancingPolicy {
   OrphanablePtr<RoundRobinEndpointList> latest_pending_endpoint_list_;
 
   bool shutdown_ = false;
-
-  absl::BitGen bit_gen_;
 };
 
 //
@@ -180,7 +179,7 @@ RoundRobin::Picker::Picker(
     : parent_(parent), pickers_(std::move(pickers)) {
   // For discussion on why we generate a random starting index for
   // the picker, see https://github.com/grpc/grpc-go/issues/2580.
-  size_t index = absl::Uniform<size_t>(parent->bit_gen_, 0, pickers_.size());
+  size_t index = absl::Uniform<size_t>(SharedBitGen(), 0, pickers_.size());
   last_picked_index_.store(index, std::memory_order_relaxed);
   GRPC_TRACE_LOG(round_robin, INFO)
       << "[RR " << parent_ << " picker " << this

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -68,6 +68,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -415,10 +416,9 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
 
   bool shutdown_ = false;
 
-  absl::BitGen bit_gen_;
-
   // Accessed by picker.
-  std::atomic<uint32_t> scheduler_state_{absl::Uniform<uint32_t>(bit_gen_)};
+  std::atomic<uint32_t> scheduler_state_{
+      absl::Uniform<uint32_t>(SharedBitGen())};
 };
 
 //
@@ -539,7 +539,7 @@ WeightedRoundRobin::Picker::Picker(RefCountedPtr<WeightedRoundRobin> wrr,
                                    WrrEndpointList* endpoint_list)
     : wrr_(std::move(wrr)),
       config_(wrr_->config_),
-      last_picked_index_(absl::Uniform<size_t>(wrr_->bit_gen_)) {
+      last_picked_index_(absl::Uniform<size_t>(SharedBitGen())) {
   for (auto& endpoint : endpoint_list->endpoints()) {
     auto* ep = static_cast<WrrEndpointList::WrrEndpoint*>(endpoint.get());
     if (ep->connectivity_state() == GRPC_CHANNEL_READY) {

data/src/core/load_balancing/weighted_target/weighted_target.cc

@@ -59,6 +59,7 @@
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -139,11 +140,6 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
 
    private:
     PickerList pickers_;
-
-    // TODO(roth): Consider using a separate thread-local BitGen for each CPU
-    // to avoid the need for this mutex.
-    Mutex mu_;
-    absl::BitGen bit_gen_ ABSL_GUARDED_BY(&mu_);
   };
 
   // Each WeightedChild holds a ref to its parent WeightedTargetLb.
@@ -250,10 +246,8 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
 WeightedTargetLb::PickResult WeightedTargetLb::WeightedPicker::Pick(
     PickArgs args) {
   // Generate a random number in [0, total weight).
-  const uint64_t key = [&]() {
-    MutexLock lock(&mu_);
-    return absl::Uniform<uint64_t>(bit_gen_, 0, pickers_.back().first);
-  }();
+  const uint64_t key =
+      absl::Uniform<uint64_t>(SharedBitGen(), 0, pickers_.back().first);
   // Find the index in pickers_ corresponding to key.
   size_t mid = 0;
   size_t start_index = 0;

data/src/core/load_balancing/xds/cds.cc

@@ -397,7 +397,14 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
             cluster_name_, new_cluster_config->cluster->use_http_connect,
             endpoint_config.endpoints,
             child_name_state_.priority_child_numbers);
-        update_args.resolution_note = endpoint_config.resolution_note;
+        std::vector<absl::string_view> resolution_notes;
+        if (!args.resolution_note.empty()) {
+          resolution_notes.emplace_back(args.resolution_note);
+        }
+        if (!endpoint_config.resolution_note.empty()) {
+          resolution_notes.emplace_back(endpoint_config.resolution_note);
+        }
+        update_args.resolution_note = absl::StrJoin(resolution_notes, "; ");
         // Construct child policy config.
         child_policy_config_json = CreateChildPolicyConfigForLeafCluster(
             *new_cluster_config, endpoint_config, aggregate_cluster_resource);
@@ -405,6 +412,8 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
       // Aggregate cluster.
       [&](const XdsConfig::ClusterConfig::AggregateConfig& aggregate_config) {
         child_name_state_.Reset();
+        // Populate resolution_note for child policy.
+        update_args.resolution_note = aggregate_config.resolution_note;
         // Construct child policy config.
         child_policy_config_json =
             CreateChildPolicyConfigForAggregateCluster(aggregate_config);

data/src/core/load_balancing/xds/xds_override_host.cc

@@ -286,6 +286,15 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
       address_list_ = std::move(address_list);
     }
 
+    const ChannelArgs& per_endpoint_args() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return per_endpoint_args_;
+    }
+    void set_per_endpoint_args(ChannelArgs per_endpoint_args)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      per_endpoint_args_ = std::move(per_endpoint_args);
+    }
+
     Timestamp last_used_time() const
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
       return last_used_time_;
@@ -304,6 +313,7 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
         &XdsOverrideHostLb::mu_) = XdsHealthStatus(XdsHealthStatus::kUnknown);
     RefCountedStringValue address_list_
         ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
+    ChannelArgs per_endpoint_args_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
     Timestamp last_used_time_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_) =
         Timestamp::InfPast();
   };
@@ -319,30 +329,6 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
     PickResult Pick(PickArgs args) override;
 
    private:
-    class SubchannelConnectionRequester final {
-     public:
-      explicit SubchannelConnectionRequester(
-          RefCountedPtr<SubchannelWrapper> subchannel)
-          : subchannel_(std::move(subchannel)) {
-        GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-        // Hop into ExecCtx, so that we don't get stuck running
-        // arbitrary WorkSerializer callbacks while doing a pick.
-        ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-      }
-
-     private:
-      static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
-        auto* self = static_cast<SubchannelConnectionRequester*>(arg);
-        self->subchannel_->policy()->work_serializer()->Run([self]() {
-          self->subchannel_->RequestConnection();
-          delete self;
-        });
-      }
-
-      RefCountedPtr<SubchannelWrapper> subchannel_;
-      grpc_closure closure_;
-    };
-
     std::optional<LoadBalancingPolicy::PickResult> PickOverriddenHost(
         XdsOverrideHostAttribute* override_host_attr) const;
 
@@ -493,7 +479,10 @@ XdsOverrideHostLb::Picker::PickOverriddenHost(
     GRPC_TRACE_LOG(xds_override_host_lb, INFO)
         << "Picker override found IDLE subchannel";
     // Deletes itself after the connection is requested.
-    new SubchannelConnectionRequester(std::move(idle_subchannel));
+    policy_->work_serializer()->Run(
+        [subchannel = std::move(idle_subchannel)]() {
+          subchannel->RequestConnection();
+        });
     return PickResult::Queue();
   }
   // No READY or IDLE subchannels.  If we found a CONNECTING subchannel,
@@ -793,8 +782,12 @@ void XdsOverrideHostLb::UpdateAddressMap(
   struct AddressInfo {
     XdsHealthStatus eds_health_status;
     RefCountedStringValue address_list;
-    AddressInfo(XdsHealthStatus status, RefCountedStringValue addresses)
-        : eds_health_status(status), address_list(std::move(addresses)) {}
+    ChannelArgs per_endpoint_args;
+    AddressInfo(XdsHealthStatus status, RefCountedStringValue addresses,
+                ChannelArgs args)
+        : eds_health_status(status),
+          address_list(std::move(addresses)),
+          per_endpoint_args(std::move(args)) {}
   };
   std::map<const std::string, AddressInfo> addresses_for_map;
   endpoints.ForEach([&](const EndpointAddresses& endpoint) {
@@ -830,7 +823,8 @@ void XdsOverrideHostLb::UpdateAddressMap(
                        (end.empty() ? "" : ","), end));
       addresses_for_map.emplace(
           std::piecewise_construct, std::forward_as_tuple(addresses[i]),
-          std::forward_as_tuple(status, std::move(address_list)));
+          std::forward_as_tuple(status, std::move(address_list),
+                                endpoint.args()));
     }
   });
   // Now grab the lock and update subchannel_map_ from addresses_for_map.
@@ -865,9 +859,12 @@ void XdsOverrideHostLb::UpdateAddressMap(
           << "[xds_override_host_lb " << this << "] map key " << address
           << ": setting "
           << "eds_health_status=" << address_info.eds_health_status.ToString()
-          << " address_list=" << address_info.address_list.c_str();
+          << " address_list=" << address_info.address_list.c_str()
+          << " per_endpoint_args=" << address_info.per_endpoint_args.ToString();
       it->second->set_eds_health_status(address_info.eds_health_status);
       it->second->set_address_list(std::move(address_info.address_list));
+      it->second->set_per_endpoint_args(
+          std::move(address_info.per_endpoint_args));
       // Check the entry's last_used_time to determine the next time at
       // which the timer needs to run.
       if (it->second->last_used_time() > idle_threshold) {
@@ -908,14 +905,38 @@ void XdsOverrideHostLb::CreateSubchannelForAddress(absl::string_view address) {
       << address;
   auto addr = StringToSockaddr(address);
   CHECK(addr.ok());
-  // Note: We don't currently have any cases where per_address_args need to
-  // be passed through.  If we encounter any such cases in the future, we
-  // will need to change this to store those attributes from the resolver
-  // update in the map entry.
+  // We need to do 3 things here:
+  // 1. Get the per-endpoint args from the entry in subchannel_map_.
+  // 2. Create the subchannel using those per-endpoint args.
+  // 3. Wrap the subchannel and store the wrapper in subchannel_map_.
+  //
+  // Steps 1 and 3 require holding the lock, but we don't want to hold
+  // the lock in step 2, since we're calling into arbitrary code in the
+  // channel.  Unfortunately, this means we need to grab and release the
+  // lock twice -- and each time, we need to check if some other thread
+  // has preempted us.
+  //
+  // Step 1.
+  ChannelArgs per_endpoint_args;
+  {
+    MutexLock lock(&mu_);
+    auto it = subchannel_map_.find(address);
+    // This can happen if the map entry was removed between the time that
+    // the picker requested the subchannel creation and the time that we got
+    // here.  In that case, we can just make it a no-op, since the update
+    // that removed the entry will have generated a new picker already.
+    if (it == subchannel_map_.end()) return;
+    // This can happen if the picker requests subchannel creation for
+    // the same address multiple times.
+    if (it->second->HasOwnedSubchannel()) return;
+    per_endpoint_args = it->second->per_endpoint_args();
+  }
+  // Step 2.
   auto subchannel = channel_control_helper()->CreateSubchannel(
-      *addr, /*per_address_args=*/ChannelArgs(), args_);
+      *addr, per_endpoint_args, args_);
   auto wrapper = MakeRefCounted<SubchannelWrapper>(
       std::move(subchannel), RefAsSubclass<XdsOverrideHostLb>());
+  // Step 3.
   {
     MutexLock lock(&mu_);
     auto it = subchannel_map_.find(address);

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -70,6 +70,7 @@ extern void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 extern void RegisterConnectedChannel(CoreConfiguration::Builder* builder);
 extern void RegisterLoadBalancedCallDestination(
     CoreConfiguration::Builder* builder);
+extern void RegisterChttp2Transport(CoreConfiguration::Builder* builder);
 #ifndef GRPC_NO_RLS
 extern void RegisterRlsLbPolicy(CoreConfiguration::Builder* builder);
 #endif  // !GRPC_NO_RLS
@@ -98,6 +99,7 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterEndpointInfoHandshaker(builder);
   RegisterHttpConnectHandshaker(builder);
   RegisterTCPConnectHandshaker(builder);
+  RegisterChttp2Transport(builder);
   RegisterPriorityLbPolicy(builder);
   RegisterOutlierDetectionLbPolicy(builder);
   RegisterWeightedTargetLbPolicy(builder);

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -28,6 +28,7 @@ extern void GcpAuthenticationFilterRegister(
 extern void RegisterXdsChannelStackModifier(
     CoreConfiguration::Builder* builder);
 extern void RegisterChannelDefaultCreds(CoreConfiguration::Builder* builder);
+extern void RegisterDefaultCallCreds(CoreConfiguration::Builder* builder);
 extern void RegisterXdsResolver(CoreConfiguration::Builder* builder);
 extern void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder);
 extern void RegisterXdsClusterManagerLbPolicy(
@@ -52,6 +53,7 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   GcpAuthenticationFilterRegister(builder);
   RegisterXdsChannelStackModifier(builder);
   RegisterChannelDefaultCreds(builder);
+  RegisterDefaultCallCreds(builder);
   RegisterXdsResolver(builder);
   RegisterCloud2ProdResolver(builder);
   RegisterXdsClusterManagerLbPolicy(builder);

data/src/core/resolver/sockaddr/sockaddr_resolver.cc

@@ -86,7 +86,8 @@ bool ParseUri(const URI& uri,
       // Skip targets which are empty.
       continue;
     }
-    auto ith_uri = URI::Create(uri.scheme(), "", std::string(ith_path), {}, "");
+    auto ith_uri = URI::Create(uri.scheme(), /*user_info=*/"", /*host_port=*/"",
+                               std::string(ith_path), {}, "");
     grpc_resolved_address addr;
     if (!ith_uri.ok() || !parse(*ith_uri, &addr)) {
       errors_found = true;

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

@@ -41,10 +41,10 @@ XdsConfig::ClusterConfig::ClusterConfig(
 
 XdsConfig::ClusterConfig::ClusterConfig(
     std::shared_ptr<const XdsClusterResource> cluster,
-    std::vector<absl::string_view> leaf_clusters)
+    std::vector<absl::string_view> leaf_clusters, std::string resolution_note)
     : cluster(std::move(cluster)),
       children(absl::in_place_type_t<AggregateConfig>(),
-               std::move(leaf_clusters)) {}
+               std::move(leaf_clusters), std::move(resolution_note)) {}
 
 //
 // XdsConfig
@@ -81,7 +81,10 @@ std::string XdsConfig::ToString() const {
           [&](const ClusterConfig::AggregateConfig& aggregate_config) {
             parts.push_back(absl::StrCat(
                 "        leaf_clusters: [",
-                absl::StrJoin(aggregate_config.leaf_clusters, ", "), "]\n"));
+                absl::StrJoin(aggregate_config.leaf_clusters, ", "),
+                "],\n"
+                "        resolution_note: \"",
+                aggregate_config.resolution_note, "\"\n"));
           });
       parts.push_back(
           "      }\n"

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

@@ -66,11 +66,15 @@ struct XdsConfig : public RefCounted<XdsConfig> {
     // The list of leaf clusters for an aggregate cluster.
     struct AggregateConfig {
       std::vector<absl::string_view> leaf_clusters;
+      std::string resolution_note;
 
-      explicit AggregateConfig(std::vector<absl::string_view> leaf_clusters)
-          : leaf_clusters(std::move(leaf_clusters)) {}
+      AggregateConfig(std::vector<absl::string_view> leaf_clusters,
+                      std::string resolution_note)
+          : leaf_clusters(std::move(leaf_clusters)),
+            resolution_note(std::move(resolution_note)) {}
       bool operator==(const AggregateConfig& other) const {
-        return leaf_clusters == other.leaf_clusters;
+        return leaf_clusters == other.leaf_clusters &&
+               resolution_note == other.resolution_note;
       }
     };
     std::variant<EndpointConfig, AggregateConfig> children;
@@ -81,7 +85,8 @@ struct XdsConfig : public RefCounted<XdsConfig> {
                   std::string resolution_note);
     // Ctor for aggregate clusters.
     ClusterConfig(std::shared_ptr<const XdsClusterResource> cluster,
-                  std::vector<absl::string_view> leaf_clusters);
+                  std::vector<absl::string_view> leaf_clusters,
+                  std::string resolution_note);
 
     bool operator==(const ClusterConfig& other) const {
       return cluster == other.cluster && children == other.children;

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

@@ -656,8 +656,12 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         cluster_config_map,
     std::set<absl::string_view>* eds_resources_seen,
     std::set<absl::string_view>* dns_names_seen,
-    absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters) {
-  if (depth > 0) CHECK_NE(leaf_clusters, nullptr);
+    absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters,
+    std::vector<std::string>* resolution_notes) {
+  if (depth > 0) {
+    CHECK_NE(leaf_clusters, nullptr);
+    CHECK_NE(resolution_notes, nullptr);
+  }
   if (depth == kMaxXdsAggregateClusterRecursionDepth) {
     *leaf_clusters =
         absl::UnavailableError("aggregate cluster graph exceeds max depth");
@@ -687,6 +691,9 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
   // If there was an error fetching the CDS resource, report the error.
   if (!state.update.ok()) {
     cluster_config = state.update.status();
+    if (resolution_notes != nullptr) {
+      resolution_notes->emplace_back(state.update.status().message());
+    }
     return true;
   }
   // If we don't have the resource yet, we can't return a config yet.
@@ -785,12 +792,13 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         // Recursively expand leaf clusters.
         absl::StatusOr<std::vector<absl::string_view>> child_leaf_clusters;
         child_leaf_clusters.emplace();
+        std::vector<std::string> child_resolution_notes;
         bool have_all_resources = true;
         for (const std::string& child_name :
              aggregate.prioritized_cluster_names) {
           have_all_resources &= PopulateClusterConfigMap(
               child_name, depth + 1, cluster_config_map, eds_resources_seen,
-              dns_names_seen, &child_leaf_clusters);
+              dns_names_seen, &child_leaf_clusters, &child_resolution_notes);
           if (!child_leaf_clusters.ok()) break;
         }
         // Note that we cannot use the cluster_config reference we
@@ -807,12 +815,18 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
           }
           return true;
         }
-        // If needed, propagate leaf cluster list up the tree.
+        // If needed, propagate leaf cluster list and resolution note
+        // lists up the tree.
         if (leaf_clusters != nullptr) {
           (*leaf_clusters)
               ->insert((*leaf_clusters)->end(), child_leaf_clusters->begin(),
                        child_leaf_clusters->end());
         }
+        if (resolution_notes != nullptr) {
+          resolution_notes->insert(resolution_notes->end(),
+                                   child_resolution_notes.begin(),
+                                   child_resolution_notes.end());
+        }
         // If there are no leaf clusters, report an error for the cluster.
         if (have_all_resources && child_leaf_clusters->empty()) {
           aggregate_cluster_config = absl::UnavailableError(
@@ -825,8 +839,9 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         // at the root of the tree, because we need to make sure the list
         // of underlying cluster names stays alive so that the leaf cluster
         // list of the root aggregate cluster can point to those strings.
-        aggregate_cluster_config.emplace(std::move(cluster_resource),
-                                         std::move(*child_leaf_clusters));
+        aggregate_cluster_config.emplace(
+            std::move(cluster_resource), std::move(*child_leaf_clusters),
+            absl::StrJoin(child_resolution_notes, "; "));
         return have_all_resources;
       });
 }

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

@@ -172,7 +172,8 @@ class XdsDependencyManager final : public RefCounted<XdsDependencyManager>,
           cluster_config_map,
       std::set<absl::string_view>* eds_resources_seen,
       std::set<absl::string_view>* dns_names_seen,
-      absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters = nullptr);
+      absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters = nullptr,
+      std::vector<std::string>* resolution_notes = nullptr);
 
   // Called when an external cluster subscription is unreffed.
   void OnClusterSubscriptionUnref(absl::string_view cluster_name,

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

@@ -51,6 +51,7 @@
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -78,6 +79,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 #include "src/core/util/uri.h"
 #include "src/core/util/work_serializer.h"
@@ -273,12 +275,16 @@ class XdsResolver final : public Resolver {
 
     absl::Status GetCallConfig(GetCallConfigArgs args) override;
 
-    void AddFilters(InterceptionChainBuilder& builder) override;
+    void AddFilters(InterceptionChainBuilder& builder,
+                    const Blackboard* old_blackboard,
+                    Blackboard* new_blackboard) override;
 
-    std::vector<const grpc_channel_filter*> GetFilters() override;
+    std::vector<const grpc_channel_filter*> GetFilters(
+        const Blackboard* old_blackboard, Blackboard* new_blackboard) override;
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
+    std::shared_ptr<const XdsListenerResource> listener_;
     RefCountedPtr<RouteConfigData> route_config_data_;
     std::vector<const XdsHttpFilterImpl*> filters_;
   };
@@ -516,7 +522,7 @@ absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
     XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
     const Duration& default_max_stream_duration) {
   GRPC_TRACE_LOG(xds_resolver, INFO)
-      << "[xds_resolver " << resolver << "] XdsConfigSelector " << this
+      << "[xds_resolver " << resolver << "] RouteConfigData " << this
       << ": route: " << route.ToString();
   routes_.emplace_back(route);
   auto* route_entry = &routes_.back();
@@ -605,18 +611,19 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     RefCountedPtr<XdsResolver> resolver,
     RefCountedPtr<RouteConfigData> route_config_data)
     : resolver_(std::move(resolver)),
+      listener_(resolver_->current_config_->listener),
       route_config_data_(std::move(route_config_data)) {
   GRPC_TRACE_LOG(xds_resolver, INFO) << "[xds_resolver " << resolver_.get()
                                      << "] creating XdsConfigSelector " << this;
   // Populate filter list.
   const auto& http_filter_registry =
-      static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
           .http_filter_registry();
-  const auto& hcm = std::get<XdsListenerResource::HttpConnectionManager>(
-      resolver_->current_config_->listener->listener);
+  const auto& hcm =
+      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
   for (const auto& http_filter : hcm.http_filters) {
     // Find filter.  This is guaranteed to succeed, because it's checked
-    // at config validation time in the XdsApi code.
+    // at config validation time.
     const XdsHttpFilterImpl* filter_impl =
         http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
@@ -690,7 +697,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
           XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
           /*weighted_clusters*/) {
         const uint32_t key = absl::Uniform<uint32_t>(
-            absl::BitGen(), 0, entry->weighted_cluster_state.back().range_end);
+            SharedBitGen(), 0, entry->weighted_cluster_state.back().range_end);
         // Find the index in weighted clusters corresponding to key.
         size_t mid = 0;
         size_t start_index = 0;
@@ -770,20 +777,34 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
 }
 
 void XdsResolver::XdsConfigSelector::AddFilters(
-    InterceptionChainBuilder& builder) {
-  for (const XdsHttpFilterImpl* filter : filters_) {
+    InterceptionChainBuilder& builder, const Blackboard* old_blackboard,
+    Blackboard* new_blackboard) {
+  const auto& hcm =
+      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
+  CHECK_EQ(filters_.size(), hcm.http_filters.size());
+  for (size_t i = 0; i < filters_.size(); ++i) {
+    auto* filter = filters_[i];
     filter->AddFilter(builder);
+    filter->UpdateBlackboard(hcm.http_filters[i].config, old_blackboard,
+                             new_blackboard);
   }
   builder.Add<ClusterSelectionFilter>();
 }
 
 std::vector<const grpc_channel_filter*>
-XdsResolver::XdsConfigSelector::GetFilters() {
+XdsResolver::XdsConfigSelector::GetFilters(const Blackboard* old_blackboard,
+                                           Blackboard* new_blackboard) {
+  const auto& hcm =
+      std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
+  CHECK_EQ(filters_.size(), hcm.http_filters.size());
   std::vector<const grpc_channel_filter*> filters;
-  for (const XdsHttpFilterImpl* filter : filters_) {
+  for (size_t i = 0; i < filters_.size(); ++i) {
+    auto* filter = filters_[i];
     if (filter->channel_filter() != nullptr) {
       filters.push_back(filter->channel_filter());
     }
+    filter->UpdateBlackboard(hcm.http_filters[i].config, old_blackboard,
+                             new_blackboard);
   }
   filters.push_back(&ClusterSelectionFilter::kFilter);
   return filters;