grpc 1.81.1 → 1.83.0

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

@@ -80,53 +80,102 @@ class XdsRouting final {
       grpc_metadata_batch* initial_metadata, absl::string_view header_name,
       std::string* concatenated_value);
 
-  // Logic for building a filter chain for a given route.  Caching is
-  // done to avoid unnecessary work while iterating over the list of
-  // routes in a given VirtualHost.
+  // Logic for building filter chains for each route within a
+  // RouteConfiguration.  Caching is done to avoid unnecessary work while
+  // iterating over the list of routes.
   //
   // TODO(roth): Currently, this class uses the xds_resolver tracer for
   // logging.  When we change the server side to use the new filter
   // config structure, add a new tracer and use that instead, so that it
   // can be used on both the client and server side.
-  class PerRouteFilterChainBuilder {
+  class RouteConfigFilterChainBuilder {
    public:
+    // Builds filter chains for each route within a VirtualHost.
+    class VirtualHostFilterChainBuilder {
+     public:
+      // Builds filter chains for each ClusterWeight within a route.
+      class WeightedClusterRouteFilterChainBuilder {
+       public:
+        WeightedClusterRouteFilterChainBuilder(
+            VirtualHostFilterChainBuilder& vhost_builder,
+            const XdsRouteConfigResource::Route& route)
+            : vhost_builder_(vhost_builder), route_(route) {}
+
+        // Builds a filter chain for a ClusterWeight.
+        absl::StatusOr<RefCountedPtr<const FilterChain>>
+        BuildFilterChainForClusterWeight(
+            const XdsRouteConfigResource::Route::RouteAction::ClusterWeight&
+                cluster_weight);
+
+       private:
+        absl::StatusOr<RefCountedPtr<const FilterChain>> GetRouteFilterChain();
+
+        VirtualHostFilterChainBuilder& vhost_builder_;
+        const XdsRouteConfigResource::Route& route_;
+
+        // Cached filter chain for the route, to be used for any ClusterWeight
+        // that does not have any filter config overrides.
+        absl::StatusOr<RefCountedPtr<const FilterChain>> route_filter_chain_ =
+            nullptr;
+      };
+
+      VirtualHostFilterChainBuilder(
+          RouteConfigFilterChainBuilder& route_config_builder,
+          const XdsRouteConfigResource::VirtualHost& vhost)
+          : route_config_builder_(route_config_builder), vhost_(vhost) {}
+
+      // Builds a filter chain for a route that has an individual cluster
+      // or a ClusterSpecifierPlugin.
+      absl::StatusOr<RefCountedPtr<const FilterChain>> BuildFilterChainForRoute(
+          const XdsRouteConfigResource::Route& route);
+
+      // Returns a filter chain builder for a given route that uses
+      // WeightedClusters.
+      WeightedClusterRouteFilterChainBuilder
+      MakeWeightedClusterRouteFilterChainBuilder(
+          const XdsRouteConfigResource::Route& route) {
+        return WeightedClusterRouteFilterChainBuilder(*this, route);
+      }
+
+     private:
+      absl::StatusOr<RefCountedPtr<const FilterChain>>
+      GetVirtualHostFilterChain();
+
+      RouteConfigFilterChainBuilder& route_config_builder_;
+      const XdsRouteConfigResource::VirtualHost& vhost_;
+
+      // Cached filter chain for the virtual host, to be used for any route
+      // that does not have any filter config overrides.
+      absl::StatusOr<RefCountedPtr<const FilterChain>> vhost_filter_chain_ =
+          nullptr;
+    };
+
     // The add_last_filter() callback is called on the builder after
     // adding all of the xDS HTTP filters and right before building the
     // filter chain.  May be null if not needed.
-    PerRouteFilterChainBuilder(
+    RouteConfigFilterChainBuilder(
         const std::vector<
             XdsListenerResource::HttpConnectionManager::HttpFilter>&
             hcm_filter_configs,
         const XdsHttpFilterRegistry& http_filter_registry,
-        const XdsRouteConfigResource::VirtualHost& vhost,
         FilterChainBuilder& builder,
         absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter,
-        const Blackboard* old_blackboard, Blackboard* new_blackboard);
-
-    // Builds a filter chain for a route that has an individual cluster
-    // or a ClusterSpecifierPlugin.
-    absl::StatusOr<RefCountedPtr<const FilterChain>> BuildFilterChainForRoute(
-        const XdsRouteConfigResource::Route& route);
-
-    // Builds a filter chain for a route that uses WeightedClusters.
-    // The set_filter_chain_for_cluster_weight() function will be called
-    // once for each index in the WeightedClusters list.
-    void BuildFilterChainForRouteWithWeightedClusters(
-        const XdsRouteConfigResource::Route& route,
-        absl::FunctionRef<
-            void(size_t, absl::StatusOr<RefCountedPtr<const FilterChain>>)>
-            set_filter_chain_for_cluster_weight);
+        Blackboard& blackboard);
+
+    // Returns a filter chain builder for a given virtual host.
+    VirtualHostFilterChainBuilder MakeVirtualHostFilterChainBuilder(
+        const XdsRouteConfigResource::VirtualHost& vhost) {
+      return VirtualHostFilterChainBuilder(*this, vhost);
+    }
 
    private:
     absl::StatusOr<RefCountedPtr<const FilterChain>> GetDefaultFilterChain();
 
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         hcm_filter_configs_;
-    const XdsRouteConfigResource::VirtualHost& vhost_;
     FilterChainBuilder& builder_;
     absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter_;
-    const Blackboard* old_blackboard_;
-    Blackboard* new_blackboard_;
+    Blackboard& blackboard_;
 
     // Same size as hcm_filter_configs_.
     std::vector<const XdsHttpFilterImpl*> filter_impls_;

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

@@ -24,11 +24,10 @@
 #include <vector>
 
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/json/json_writer.h"
-#include "src/core/util/string.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
@@ -98,16 +97,6 @@ struct ChannelOrCallCreds {
   }
 };
 
-// TODO(roth): Remove this guard once we have reports from OSS Istio
-// users that this works properly.
-bool XdsBootstrapCallCredsEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_BOOTSTRAP_CALL_CREDS");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 }  // namespace
 
 RefCountedPtr<const ChannelCredsConfig> ParseXdsBootstrapChannelCreds(
@@ -170,7 +159,9 @@ void GrpcXdsServer::JsonPostLoad(const Json& json, const JsonArgs& args,
       ParseXdsBootstrapChannelCreds(json, args, errors);
   // Parse "call_creds".
   std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs;
-  if (XdsBootstrapCallCredsEnabled()) {
+  // TODO(roth): Remove this guard once we have reports from OSS Istio
+  // users that this works properly.
+  if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_BOOTSTRAP_CALL_CREDS")) {
     call_creds_configs = ParseXdsBootstrapCallCreds(json, args, errors);
   }
   // Parse "server_features".
@@ -238,6 +229,22 @@ std::string GrpcXdsServerTarget::Key() const {
     StrAppend(result, call_creds_config->ToString());
     StrAppend(result, "}");
   }
+  if (!initial_metadata_.empty()) {
+    StrAppend(result, ", initial_metadata=[");
+    bool is_first = true;
+    for (const auto& metadata : initial_metadata_) {
+      if (!is_first) StrAppend(result, ", ");
+      StrAppend(result, metadata.first);
+      StrAppend(result, "=");
+      StrAppend(result, metadata.second);
+      is_first = false;
+    }
+    StrAppend(result, "]");
+  }
+  if (timeout_ != Duration::Zero()) {
+    StrAppend(result, ", timeout=");
+    StrAppend(result, timeout_.ToString());
+  }
   StrAppend(result, "}");
   return result;
 }
@@ -258,6 +265,8 @@ bool GrpcXdsServerTarget::Equals(const XdsServerTarget& other) const {
       return false;
     }
   }
+  if (initial_metadata_ != o.initial_metadata_) return false;
+  if (timeout_ != o.timeout_) return false;
   return true;
 }
 

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

@@ -19,6 +19,8 @@
 
 #include <set>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "src/core/credentials/call/call_creds_registry.h"
 #include "src/core/credentials/transport/channel_creds_registry.h"
@@ -26,6 +28,7 @@
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_server_grpc_interface.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
@@ -43,10 +46,14 @@ class GrpcXdsServerTarget final : public GrpcXdsServerInterface {
   explicit GrpcXdsServerTarget(
       std::string server_uri,
       RefCountedPtr<const ChannelCredsConfig> channel_creds_config,
-      std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs)
+      std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs,
+      std::vector<std::pair<std::string, std::string>> initial_metadata = {},
+      Duration timeout = Duration::Infinity())
       : server_uri_(std::move(server_uri)),
         channel_creds_config_(std::move(channel_creds_config)),
-        call_creds_configs_(std::move(call_creds_configs)) {}
+        call_creds_configs_(std::move(call_creds_configs)),
+        initial_metadata_(std::move(initial_metadata)),
+        timeout_(timeout) {}
 
   bool Equals(const XdsServerTarget& other) const override;
   std::string Key() const override;
@@ -59,11 +66,18 @@ class GrpcXdsServerTarget final : public GrpcXdsServerInterface {
       const override {
     return call_creds_configs_;
   }
+  const std::vector<std::pair<std::string, std::string>>& initial_metadata()
+      const override {
+    return initial_metadata_;
+  }
+  Duration timeout() const override { return timeout_; }
 
  private:
   std::string server_uri_;
   RefCountedPtr<const ChannelCredsConfig> channel_creds_config_;
   std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs_;
+  std::vector<std::pair<std::string, std::string>> initial_metadata_;
+  Duration timeout_;
 };
 
 class GrpcXdsServer final : public XdsBootstrap::XdsServer {

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

@@ -17,9 +17,14 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_SERVER_GRPC_INTERFACE_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_SERVER_GRPC_INTERFACE_H
 
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "src/core/credentials/call/call_creds_registry.h"
 #include "src/core/credentials/transport/channel_creds_registry.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/time.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {
@@ -31,6 +36,11 @@ class GrpcXdsServerInterface : public XdsBootstrap::XdsServerTarget {
 
   virtual const std::vector<RefCountedPtr<const CallCredsConfig>>&
   call_creds_configs() const = 0;
+
+  virtual const std::vector<std::pair<std::string, std::string>>&
+  initial_metadata() const = 0;
+
+  virtual Duration timeout() const = 0;
 };
 
 }  // namespace grpc_core

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

@@ -28,8 +28,11 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
+#include <string>
 #include <string_view>
 #include <utility>
+#include <vector>
 
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/config/core_configuration.h"
@@ -43,6 +46,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/slice/slice.h"
@@ -56,7 +60,9 @@
 #include "src/core/util/down_cast.h"
 #include "src/core/util/grpc_check.h"
 #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/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/xds/grpc/xds_server_grpc_interface.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
@@ -71,28 +77,43 @@ namespace grpc_core {
 GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::GrpcStreamingCall(
     WeakRefCountedPtr<GrpcXdsTransportFactory> factory, Channel* channel,
     const char* method,
-    std::unique_ptr<StreamingCall::EventHandler> event_handler)
+    std::unique_ptr<StreamingCall::EventHandler> event_handler,
+    const std::vector<std::pair<std::string, std::string>>& initial_metadata,
+    Duration timeout)
     : factory_(std::move(factory)), event_handler_(std::move(event_handler)) {
+  Timestamp deadline = (timeout == Duration::Infinity())
+                           ? Timestamp::InfFuture()
+                           : Timestamp::Now() + timeout;
   // Create call.
   call_ = channel->CreateCall(
       /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS, /*cq=*/nullptr,
       factory_->interested_parties(), Slice::FromStaticString(method),
-      /*authority=*/std::nullopt, Timestamp::InfFuture(),
-      /*registered_method=*/true);
+      /*authority=*/std::nullopt, deadline,
+      /*registered_method=*/true, /*arena_init_function=*/std::nullopt);
   GRPC_CHECK_NE(call_, nullptr);
   // Init data associated with the call.
   grpc_metadata_array_init(&initial_metadata_recv_);
   grpc_metadata_array_init(&trailing_metadata_recv_);
   // Initialize closure to be used for sending messages.
   GRPC_CLOSURE_INIT(&on_request_sent_, OnRequestSent, this, nullptr);
+  GRPC_CLOSURE_INIT(&on_half_closed_, OnHalfClosed, this, nullptr);
   // Start ops on the call.
   grpc_call_error call_error;
   grpc_op ops[2];
   memset(ops, 0, sizeof(ops));
   // Send initial metadata.
+  send_initial_metadata_.resize(initial_metadata.size());
+  for (size_t i = 0; i < initial_metadata.size(); ++i) {
+    send_initial_metadata_[i].key =
+        grpc_slice_from_cpp_string(initial_metadata[i].first);
+    send_initial_metadata_[i].value =
+        grpc_slice_from_cpp_string(initial_metadata[i].second);
+  }
   grpc_op* op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  op->data.send_initial_metadata.count = 0;
+  op->data.send_initial_metadata.count = send_initial_metadata_.size();
+  op->data.send_initial_metadata.metadata =
+      send_initial_metadata_.empty() ? nullptr : send_initial_metadata_.data();
   op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY |
               GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET;
   op->reserved = nullptr;
@@ -136,6 +157,10 @@ GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
   grpc_byte_buffer_destroy(send_message_payload_);
   grpc_byte_buffer_destroy(recv_message_payload_);
   CSliceUnref(status_details_);
+  for (auto& md : send_initial_metadata_) {
+    CSliceUnref(md.key);
+    CSliceUnref(md.value);
+  }
   GRPC_CHECK_NE(call_, nullptr);
   grpc_call_unref(call_);
 }
@@ -181,6 +206,18 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
   GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
 }
 
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
+    SendHalfClose() {
+  Ref(DEBUG_LOCATION, "SendHalfClose").release();
+  grpc_op op;
+  memset(&op, 0, sizeof(op));
+  op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
+  GRPC_CHECK_NE(call_, nullptr);
+  const grpc_call_error call_error =
+      grpc_call_start_batch_and_execute(call_, &op, 1, &on_half_closed_);
+  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
+}
+
 void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
     OnRecvInitialMetadata(void* arg, grpc_error_handle /*error*/) {
   RefCountedPtr<GrpcStreamingCall> self(static_cast<GrpcStreamingCall*>(arg));
@@ -197,6 +234,11 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
   self->event_handler_->OnRequestSent(error.ok());
 }
 
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::OnHalfClosed(
+    void* arg, grpc_error_handle /*error*/) {
+  RefCountedPtr<GrpcStreamingCall> self(static_cast<GrpcStreamingCall*>(arg));
+}
+
 void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
     OnResponseReceived(void* arg, grpc_error_handle /*error*/) {
   RefCountedPtr<GrpcStreamingCall> self(static_cast<GrpcStreamingCall*>(arg));
@@ -279,23 +321,66 @@ RefCountedPtr<Channel> CreateXdsChannel(
       server.server_uri().c_str(), channel_creds.get(), args.ToC().get())));
 }
 
+std::string GetChannelKey(const GrpcXdsServerInterface& server) {
+  std::string result = "{server_uri=";
+  absl::StrAppend(&result, server.server_uri());
+  if (server.channel_creds_config() != nullptr) {
+    absl::StrAppend(
+        &result,
+        ", channel_creds={type=", server.channel_creds_config()->type(),
+        ", config=", server.channel_creds_config()->ToString(), "}");
+  }
+  for (const auto& call_creds_config : server.call_creds_configs()) {
+    absl::StrAppend(&result, ", call_creds={type=", call_creds_config->type(),
+                    ", config=", call_creds_config->ToString(), "}");
+  }
+  absl::StrAppend(&result, "}");
+  return result;
+}
+
 }  // namespace
 
+class GrpcXdsTransportFactory::SharedChannel final
+    : public RefCounted<SharedChannel> {
+ public:
+  SharedChannel(std::string key, RefCountedPtr<Channel> channel,
+                WeakRefCountedPtr<GrpcXdsTransportFactory> factory)
+      : key_(std::move(key)),
+        channel_(std::move(channel)),
+        factory_(std::move(factory)) {}
+
+  ~SharedChannel() override {
+    MutexLock lock(&factory_->mu_);
+    auto it = factory_->channels_.find(key_);
+    if (it != factory_->channels_.end() && it->second == this) {
+      factory_->channels_.erase(it);
+    }
+  }
+
+  Channel* channel() const { return channel_.get(); }
+
+ private:
+  std::string key_;
+  RefCountedPtr<Channel> channel_;
+  WeakRefCountedPtr<GrpcXdsTransportFactory> factory_;
+};
+
 GrpcXdsTransportFactory::GrpcXdsTransport::GrpcXdsTransport(
     WeakRefCountedPtr<GrpcXdsTransportFactory> factory,
+    RefCountedPtr<SharedChannel> channel,
     const XdsBootstrap::XdsServerTarget& server, absl::Status* status)
     : XdsTransport(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
                        ? "GrpcXdsTransport"
                        : nullptr),
       factory_(std::move(factory)),
-      key_(server.Key()) {
+      key_(server.Key()),
+      channel_(std::move(channel)) {
   GRPC_TRACE_LOG(xds_client, INFO)
       << "[GrpcXdsTransport " << this << "] created";
-  channel_ =
-      CreateXdsChannel(factory_->args_, *factory_->certificate_provider_store_,
-                       DownCast<const GrpcXdsServerInterface&>(server));
-  GRPC_CHECK(channel_ != nullptr);
-  if (channel_->IsLame()) {
+  const auto& grpc_server = DownCast<const GrpcXdsServerInterface&>(server);
+  initial_metadata_ = grpc_server.initial_metadata();
+  timeout_ = grpc_server.timeout();
+  if (channel_->channel()->IsLame()) {
     *status = absl::UnavailableError("xds client has a lame channel");
   }
 }
@@ -327,20 +412,20 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::Orphaned() {
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::StartConnectivityFailureWatch(
     RefCountedPtr<ConnectivityFailureWatcher> watcher) {
-  if (channel_->IsLame()) return;
+  if (channel_->channel()->IsLame()) return;
   auto* state_watcher = new StateWatcher(watcher);
   {
     MutexLock lock(&mu_);
     watchers_.emplace(watcher, state_watcher);
   }
-  channel_->AddConnectivityWatcher(
+  channel_->channel()->AddConnectivityWatcher(
       GRPC_CHANNEL_IDLE,
       OrphanablePtr<AsyncConnectivityStateWatcherInterface>(state_watcher));
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::StopConnectivityFailureWatch(
     const RefCountedPtr<ConnectivityFailureWatcher>& watcher) {
-  if (channel_->IsLame()) return;
+  if (channel_->channel()->IsLame()) return;
   StateWatcher* state_watcher = nullptr;
   {
     MutexLock lock(&mu_);
@@ -349,7 +434,7 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::StopConnectivityFailureWatch(
     state_watcher = it->second;
     watchers_.erase(it);
   }
-  channel_->RemoveConnectivityWatcher(state_watcher);
+  channel_->channel()->RemoveConnectivityWatcher(state_watcher);
 }
 
 OrphanablePtr<XdsTransportFactory::XdsTransport::StreamingCall>
@@ -357,12 +442,16 @@ GrpcXdsTransportFactory::GrpcXdsTransport::CreateStreamingCall(
     const char* method,
     std::unique_ptr<StreamingCall::EventHandler> event_handler) {
   return MakeOrphanable<GrpcStreamingCall>(
-      factory_.WeakRef(DEBUG_LOCATION, "StreamingCall"), channel_.get(), method,
-      std::move(event_handler));
+      factory_.WeakRef(DEBUG_LOCATION, "StreamingCall"), channel_->channel(),
+      method, std::move(event_handler), initial_metadata_, timeout_);
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::ResetBackoff() {
-  channel_->ResetConnectionBackoff();
+  channel_->channel()->ResetConnectionBackoff();
+}
+
+Channel* GrpcXdsTransportFactory::GrpcXdsTransport::channel() const {
+  return channel_->channel();
 }
 
 //
@@ -406,8 +495,24 @@ GrpcXdsTransportFactory::GetTransport(
     transport = it->second->RefIfNonZero().TakeAsSubclass<GrpcXdsTransport>();
   }
   if (transport == nullptr) {
+    const auto& grpc_server = DownCast<const GrpcXdsServerInterface&>(server);
+    std::string channel_key = GetChannelKey(grpc_server);
+    auto channel_it = channels_.find(channel_key);
+    RefCountedPtr<SharedChannel> channel;
+    if (channel_it != channels_.end()) {
+      channel = channel_it->second->Ref();
+    } else {
+      RefCountedPtr<Channel> raw_channel =
+          CreateXdsChannel(args_, *certificate_provider_store_, grpc_server);
+      GRPC_CHECK(raw_channel != nullptr);
+      channel = MakeRefCounted<SharedChannel>(
+          channel_key, std::move(raw_channel),
+          WeakRefAsSubclass<GrpcXdsTransportFactory>());
+      channels_.emplace(channel_key, channel.get());
+    }
     transport = MakeRefCounted<GrpcXdsTransport>(
-        WeakRefAsSubclass<GrpcXdsTransportFactory>(), server, status);
+        WeakRefAsSubclass<GrpcXdsTransportFactory>(), std::move(channel),
+        server, status);
     transports_.emplace(std::move(key), transport.get());
   }
   return transport;

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

@@ -25,6 +25,8 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -34,6 +36,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "src/core/util/time.h"
 #include "src/core/xds/grpc/certificate_provider_store_interface.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 #include "src/core/xds/xds_client/xds_transport.h"
@@ -60,6 +63,8 @@ class GrpcXdsTransportFactory final : public XdsTransportFactory {
   grpc_pollset_set* interested_parties() const { return interested_parties_; }
 
  private:
+  class SharedChannel;
+
   ChannelArgs args_;
   RefCountedPtr<CertificateProviderStoreInterface> certificate_provider_store_;
   grpc_pollset_set* interested_parties_;
@@ -67,6 +72,8 @@ class GrpcXdsTransportFactory final : public XdsTransportFactory {
   Mutex mu_;
   absl::flat_hash_map<std::string /*XdsServerTarget key*/, GrpcXdsTransport*>
       transports_ ABSL_GUARDED_BY(&mu_);
+  absl::flat_hash_map<std::string /*Channel key*/, SharedChannel*> channels_
+      ABSL_GUARDED_BY(&mu_);
 };
 
 class GrpcXdsTransportFactory::GrpcXdsTransport final
@@ -75,6 +82,7 @@ class GrpcXdsTransportFactory::GrpcXdsTransport final
   class GrpcStreamingCall;
 
   GrpcXdsTransport(WeakRefCountedPtr<GrpcXdsTransportFactory> factory,
+                   RefCountedPtr<SharedChannel> channel,
                    const XdsBootstrap::XdsServerTarget& server,
                    absl::Status* status);
   ~GrpcXdsTransport() override;
@@ -92,12 +100,16 @@ class GrpcXdsTransportFactory::GrpcXdsTransport final
 
   void ResetBackoff() override;
 
+  Channel* channel() const;
+
  private:
   class StateWatcher;
 
   WeakRefCountedPtr<GrpcXdsTransportFactory> factory_;
   std::string key_;
-  RefCountedPtr<Channel> channel_;
+  RefCountedPtr<SharedChannel> channel_;
+  std::vector<std::pair<std::string, std::string>> initial_metadata_;
+  Duration timeout_;
 
   Mutex mu_;
   absl::flat_hash_map<RefCountedPtr<ConnectivityFailureWatcher>, StateWatcher*>
@@ -107,9 +119,12 @@ class GrpcXdsTransportFactory::GrpcXdsTransport final
 class GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall final
     : public XdsTransportFactory::XdsTransport::StreamingCall {
  public:
-  GrpcStreamingCall(WeakRefCountedPtr<GrpcXdsTransportFactory> factory,
-                    Channel* channel, const char* method,
-                    std::unique_ptr<StreamingCall::EventHandler> event_handler);
+  GrpcStreamingCall(
+      WeakRefCountedPtr<GrpcXdsTransportFactory> factory, Channel* channel,
+      const char* method,
+      std::unique_ptr<StreamingCall::EventHandler> event_handler,
+      const std::vector<std::pair<std::string, std::string>>& initial_metadata,
+      Duration timeout);
   ~GrpcStreamingCall() override;
 
   void Orphan() override;
@@ -118,9 +133,12 @@ class GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall final
 
   void StartRecvMessage() override;
 
+  void SendHalfClose() override;
+
  private:
   static void OnRecvInitialMetadata(void* arg, grpc_error_handle /*error*/);
   static void OnRequestSent(void* arg, grpc_error_handle error);
+  static void OnHalfClosed(void* arg, grpc_error_handle error);
   static void OnResponseReceived(void* arg, grpc_error_handle /*error*/);
   static void OnStatusReceived(void* arg, grpc_error_handle /*error*/);
 
@@ -135,10 +153,16 @@ class GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall final
   grpc_metadata_array initial_metadata_recv_;
   grpc_closure on_recv_initial_metadata_;
 
+  // send_initial_metadata
+  std::vector<grpc_metadata> send_initial_metadata_;
+
   // send_message
   grpc_byte_buffer* send_message_payload_ = nullptr;
   grpc_closure on_request_sent_;
 
+  // half_close
+  grpc_closure on_half_closed_;
+
   // recv_message
   grpc_byte_buffer* recv_message_payload_ = nullptr;
   grpc_closure on_response_received_;