grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -18,30 +18,77 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
+#include <algorithm>
+#include <array>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_replace.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
 
 #include "src/core/ext/filters/server_config_selector/server_config_selector.h"
 #include "src/core/ext/filters/server_config_selector/server_config_selector_filter.h"
+#include "src/core/ext/xds/certificate_provider_store.h"
+#include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_certificate_provider.h"
 #include "src/core/ext/xds/xds_channel_stack_modifier.h"
-#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client_grpc.h"
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_listener.h"
+#include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/ext/xds/xds_route_config.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/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/host_port.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/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
+#include "src/core/lib/security/credentials/credentials.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"
 #include "src/core/lib/security/credentials/xds/xds_credentials.h"
+#include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_impl.h"
-#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
-#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -54,9 +101,13 @@ TraceFlag grpc_xds_server_config_fetcher_trace(false,
 // listeners from the xDS control plane.
 class XdsServerConfigFetcher : public grpc_server_config_fetcher {
  public:
-  XdsServerConfigFetcher(RefCountedPtr<XdsClient> xds_client,
+  XdsServerConfigFetcher(RefCountedPtr<GrpcXdsClient> xds_client,
                          grpc_server_xds_status_notifier notifier);
 
+  ~XdsServerConfigFetcher() override {
+    xds_client_.reset(DEBUG_LOCATION, "XdsServerConfigFetcher");
+  }
+
   void StartWatch(std::string listening_address,
                   std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
                       watcher) override;
@@ -72,7 +123,7 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
  private:
   class ListenerWatcher;
 
-  const RefCountedPtr<XdsClient> xds_client_;
+  RefCountedPtr<GrpcXdsClient> xds_client_;
   const grpc_server_xds_status_notifier serving_status_notifier_;
   Mutex mu_;
   std::map<grpc_server_config_fetcher::WatcherInterface*, ListenerWatcher*>
@@ -92,12 +143,16 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
 class XdsServerConfigFetcher::ListenerWatcher
     : public XdsListenerResourceType::WatcherInterface {
  public:
-  ListenerWatcher(RefCountedPtr<XdsClient> xds_client,
+  ListenerWatcher(RefCountedPtr<GrpcXdsClient> xds_client,
                   std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
                       server_config_watcher,
                   grpc_server_xds_status_notifier serving_status_notifier,
                   std::string listening_address);
 
+  ~ListenerWatcher() override {
+    xds_client_.reset(DEBUG_LOCATION, "ListenerWatcher");
+  }
+
   void OnResourceChanged(XdsListenerResource listener) override;
 
   void OnError(absl::Status status) override;
@@ -124,7 +179,7 @@ class XdsServerConfigFetcher::ListenerWatcher
       FilterChainMatchManager* filter_chain_match_manager)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
 
-  const RefCountedPtr<XdsClient> xds_client_;
+  RefCountedPtr<GrpcXdsClient> xds_client_;
   const std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
       server_config_watcher_;
   const grpc_server_xds_status_notifier serving_status_notifier_;
@@ -144,13 +199,17 @@ class XdsServerConfigFetcher::ListenerWatcher
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
     : public grpc_server_config_fetcher::ConnectionManager {
  public:
-  FilterChainMatchManager(RefCountedPtr<XdsClient> xds_client,
+  FilterChainMatchManager(RefCountedPtr<GrpcXdsClient> xds_client,
                           XdsListenerResource::FilterChainMap filter_chain_map,
                           absl::optional<XdsListenerResource::FilterChainData>
                               default_filter_chain);
 
-  absl::StatusOr<grpc_channel_args*> UpdateChannelArgsForConnection(
-      grpc_channel_args* args, grpc_endpoint* tcp) override;
+  ~FilterChainMatchManager() override {
+    xds_client_.reset(DEBUG_LOCATION, "FilterChainMatchManager");
+  }
+
+  absl::StatusOr<ChannelArgs> UpdateChannelArgsForConnection(
+      const ChannelArgs& args, grpc_endpoint* tcp) override;
 
   void Orphan() override;
 
@@ -198,7 +257,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
   void OnError(const std::string& resource_name, absl::Status status);
   void OnResourceDoesNotExist(const std::string& resource_name);
 
-  RefCountedPtr<XdsClient> xds_client_;
+  RefCountedPtr<GrpcXdsClient> xds_client_;
   // This ref is only kept around till the FilterChainMatchManager becomes
   // ready.
   RefCountedPtr<ListenerWatcher> listener_watcher_;
@@ -354,11 +413,15 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     : public ServerConfigSelectorProvider {
  public:
   DynamicXdsServerConfigSelectorProvider(
-      RefCountedPtr<XdsClient> xds_client, std::string resource_name,
+      RefCountedPtr<GrpcXdsClient> xds_client, std::string resource_name,
       absl::StatusOr<XdsRouteConfigResource> initial_resource,
       std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
           http_filters);
 
+  ~DynamicXdsServerConfigSelectorProvider() override {
+    xds_client_.reset(DEBUG_LOCATION, "DynamicXdsServerConfigSelectorProvider");
+  }
+
   void Orphan() override;
 
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> Watch(
@@ -373,7 +436,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   void OnError(absl::Status status);
   void OnResourceDoesNotExist();
 
-  RefCountedPtr<XdsClient> xds_client_;
+  RefCountedPtr<GrpcXdsClient> xds_client_;
   std::string resource_name_;
   std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
       http_filters_;
@@ -411,7 +474,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 //
 
 XdsServerConfigFetcher::XdsServerConfigFetcher(
-    RefCountedPtr<XdsClient> xds_client,
+    RefCountedPtr<GrpcXdsClient> xds_client,
     grpc_server_xds_status_notifier notifier)
     : xds_client_(std::move(xds_client)), serving_status_notifier_(notifier) {
   GPR_ASSERT(xds_client_ != nullptr);
@@ -433,8 +496,8 @@ void XdsServerConfigFetcher::StartWatch(
     std::unique_ptr<grpc_server_config_fetcher::WatcherInterface> watcher) {
   grpc_server_config_fetcher::WatcherInterface* watcher_ptr = watcher.get();
   auto listener_watcher = MakeRefCounted<ListenerWatcher>(
-      xds_client_, std::move(watcher), serving_status_notifier_,
-      listening_address);
+      xds_client_->Ref(DEBUG_LOCATION, "ListenerWatcher"), std::move(watcher),
+      serving_status_notifier_, listening_address);
   auto* listener_watcher_ptr = listener_watcher.get();
   XdsListenerResourceType::StartWatch(
       xds_client_.get(),
@@ -467,7 +530,7 @@ void XdsServerConfigFetcher::CancelWatch(
 //
 
 XdsServerConfigFetcher::ListenerWatcher::ListenerWatcher(
-    RefCountedPtr<XdsClient> xds_client,
+    RefCountedPtr<GrpcXdsClient> xds_client,
     std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
         server_config_watcher,
     grpc_server_xds_status_notifier serving_status_notifier,
@@ -491,7 +554,8 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
     return;
   }
   auto new_filter_chain_match_manager = MakeRefCounted<FilterChainMatchManager>(
-      xds_client_, std::move(listener.filter_chain_map),
+      xds_client_->Ref(DEBUG_LOCATION, "FilterChainMatchManager"),
+      std::move(listener.filter_chain_map),
       std::move(listener.default_filter_chain));
   MutexLock lock(&mu_);
   if (filter_chain_match_manager_ == nullptr ||
@@ -594,7 +658,7 @@ void XdsServerConfigFetcher::ListenerWatcher::
 
 XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     FilterChainMatchManager(
-        RefCountedPtr<XdsClient> xds_client,
+        RefCountedPtr<GrpcXdsClient> xds_client,
         XdsListenerResource::FilterChainMap filter_chain_map,
         absl::optional<XdsListenerResource::FilterChainData>
             default_filter_chain)
@@ -897,13 +961,10 @@ const XdsListenerResource::FilterChainData* FindFilterChainDataForSourceType(
   if (!SplitHostPort(source_uri->path(), &host, &port)) {
     return nullptr;
   }
-  grpc_resolved_address source_addr;
-  grpc_error_handle error = grpc_string_to_sockaddr(
-      &source_addr, host.c_str(), 0 /* port doesn't matter here */);
-  if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_DEBUG, "Could not parse string to socket address: %s",
-            host.c_str());
-    GRPC_ERROR_UNREF(error);
+  auto source_addr = StringToSockaddr(host, 0);  // Port doesn't matter here.
+  if (!source_addr.ok()) {
+    gpr_log(GPR_DEBUG, "Could not parse \"%s\" as socket address: %s",
+            host.c_str(), source_addr.status().ToString().c_str());
     return nullptr;
   }
   // Use kAny only if kSameIporLoopback and kExternal are empty
@@ -917,20 +978,20 @@ const XdsListenerResource::FilterChainData* FindFilterChainDataForSourceType(
     return FindFilterChainDataForSourceIp(
         source_types_array[static_cast<int>(
             XdsListenerResource::FilterChainMap::ConnectionSourceType::kAny)],
-        &source_addr, port);
+        &*source_addr, port);
   }
-  if (IsLoopbackIp(&source_addr) || host == destination_ip) {
+  if (IsLoopbackIp(&*source_addr) || host == destination_ip) {
     return FindFilterChainDataForSourceIp(
         source_types_array[static_cast<int>(
             XdsListenerResource::FilterChainMap::ConnectionSourceType::
                 kSameIpOrLoopback)],
-        &source_addr, port);
+        &*source_addr, port);
   } else {
     return FindFilterChainDataForSourceIp(
         source_types_array[static_cast<int>(
             XdsListenerResource::FilterChainMap::ConnectionSourceType::
                 kExternal)],
-        &source_addr, port);
+        &*source_addr, port);
   }
 }
 
@@ -948,13 +1009,11 @@ const XdsListenerResource::FilterChainData* FindFilterChainDataForDestinationIp(
   if (!SplitHostPort(destination_uri->path(), &host, &port)) {
     return nullptr;
   }
-  grpc_resolved_address destination_addr;
-  grpc_error_handle error = grpc_string_to_sockaddr(
-      &destination_addr, host.c_str(), 0 /* port doesn't matter here */);
-  if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_DEBUG, "Could not parse string to socket address: %s",
-            host.c_str());
-    GRPC_ERROR_UNREF(error);
+  auto destination_addr =
+      StringToSockaddr(host, 0);  // Port doesn't matter here.
+  if (!destination_addr.ok()) {
+    gpr_log(GPR_DEBUG, "Could not parse \"%s\" as socket address: %s",
+            host.c_str(), destination_addr.status().ToString().c_str());
     return nullptr;
   }
   const XdsListenerResource::FilterChainMap::DestinationIp* best_match =
@@ -972,7 +1031,7 @@ const XdsListenerResource::FilterChainData* FindFilterChainDataForDestinationIp(
             entry.prefix_range->prefix_len) {
       continue;
     }
-    if (grpc_sockaddr_match_subnet(&destination_addr,
+    if (grpc_sockaddr_match_subnet(&*destination_addr,
                                    &entry.prefix_range->address,
                                    entry.prefix_range->prefix_len)) {
       best_match = &entry;
@@ -983,19 +1042,18 @@ const XdsListenerResource::FilterChainData* FindFilterChainDataForDestinationIp(
                                           host);
 }
 
-absl::StatusOr<grpc_channel_args*> XdsServerConfigFetcher::ListenerWatcher::
+absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
     FilterChainMatchManager::UpdateChannelArgsForConnection(
-        grpc_channel_args* args, grpc_endpoint* tcp) {
+        const ChannelArgs& input_args, grpc_endpoint* tcp) {
+  ChannelArgs args = input_args;
   const auto* filter_chain = FindFilterChainDataForDestinationIp(
       filter_chain_map_.destination_ip_vector, tcp);
   if (filter_chain == nullptr && default_filter_chain_.has_value()) {
     filter_chain = &default_filter_chain_.value();
   }
   if (filter_chain == nullptr) {
-    grpc_channel_args_destroy(args);
     return absl::UnavailableError("No matching filter chain found");
   }
-  absl::InlinedVector<grpc_arg, 3> args_to_add;
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider;
   RefCountedPtr<XdsChannelStackModifier> channel_stack_modifier;
   RefCountedPtr<XdsCertificateProvider> xds_certificate_provider;
@@ -1036,34 +1094,27 @@ absl::StatusOr<grpc_channel_args*> XdsServerConfigFetcher::ListenerWatcher::
       }
       server_config_selector_provider =
           MakeRefCounted<DynamicXdsServerConfigSelectorProvider>(
-              xds_client_,
+              xds_client_->Ref(DEBUG_LOCATION,
+                               "DynamicXdsServerConfigSelectorProvider"),
               filter_chain->http_connection_manager.route_config_name,
               std::move(initial_resource),
               filter_chain->http_connection_manager.http_filters);
     }
-    args_to_add.emplace_back(server_config_selector_provider->MakeChannelArg());
-    args_to_add.emplace_back(channel_stack_modifier->MakeChannelArg());
+    args = args.SetObject(server_config_selector_provider)
+               .SetObject(channel_stack_modifier);
   }
   // Add XdsCertificateProvider if credentials are xDS.
-  grpc_server_credentials* server_creds =
-      grpc_find_server_credentials_in_args(args);
+  auto* server_creds = args.GetObject<grpc_server_credentials>();
   if (server_creds != nullptr &&
       server_creds->type() == XdsServerCredentials::Type()) {
     absl::StatusOr<RefCountedPtr<XdsCertificateProvider>> result =
         CreateOrGetXdsCertificateProviderFromFilterChainData(filter_chain);
     if (!result.ok()) {
-      grpc_channel_args_destroy(args);
       return result.status();
     }
     xds_certificate_provider = std::move(*result);
     GPR_ASSERT(xds_certificate_provider != nullptr);
-    args_to_add.emplace_back(xds_certificate_provider->MakeChannelArg());
-  }
-  if (!args_to_add.empty()) {
-    grpc_channel_args* updated_args = grpc_channel_args_copy_and_add(
-        args, args_to_add.data(), args_to_add.size());
-    grpc_channel_args_destroy(args);
-    args = updated_args;
+    args = args.SetObject(xds_certificate_provider);
   }
   return args;
 }
@@ -1093,15 +1144,12 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       config_selector_route.unsupported_action =
           absl::get_if<XdsRouteConfigResource::Route::NonForwardingAction>(
               &route.action) == nullptr;
-      XdsRouting::GeneratePerHttpFilterConfigsResult result =
-          XdsRouting::GeneratePerHTTPFilterConfigs(http_filters, vhost, route,
-                                                   nullptr, nullptr);
-      if (result.error != GRPC_ERROR_NONE) {
-        return grpc_error_to_absl_status(result.error);
-      }
+      auto result = XdsRouting::GeneratePerHTTPFilterConfigs(
+          http_filters, vhost, route, nullptr, ChannelArgs());
+      if (!result.ok()) return result.status();
       std::vector<std::string> fields;
-      fields.reserve(result.per_filter_configs.size());
-      for (const auto& p : result.per_filter_configs) {
+      fields.reserve(result->per_filter_configs.size());
+      for (const auto& p : result->per_filter_configs) {
         fields.emplace_back(absl::StrCat("    \"", p.first, "\": [\n",
                                          absl::StrJoin(p.second, ",\n"),
                                          "\n    ]"));
@@ -1117,12 +1165,9 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
             absl::StrJoin(fields, ",\n"),
             "\n  } ]\n"
             "}");
-        grpc_error_handle error = GRPC_ERROR_NONE;
         config_selector_route.method_config =
-            ServiceConfigImpl::Create(result.args, json.c_str(), &error);
-        GPR_ASSERT(error == GRPC_ERROR_NONE);
+            ServiceConfigImpl::Create(result->args, json.c_str()).value();
       }
-      grpc_channel_args_destroy(result.args);
     }
   }
   return config_selector;
@@ -1188,7 +1233,7 @@ ServerConfigSelector::CallConfig XdsServerConfigFetcher::ListenerWatcher::
 XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     DynamicXdsServerConfigSelectorProvider::
         DynamicXdsServerConfigSelectorProvider(
-            RefCountedPtr<XdsClient> xds_client, std::string resource_name,
+            RefCountedPtr<GrpcXdsClient> xds_client, std::string resource_name,
             absl::StatusOr<XdsRouteConfigResource> initial_resource,
             std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>
                 http_filters)
@@ -1285,25 +1330,22 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     grpc_server_xds_status_notifier notifier, const grpc_channel_args* args) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  args = grpc_core::CoreConfiguration::Get()
-             .channel_args_preconditioning()
-             .PreconditionChannelArgs(args)
-             .ToC();
+  grpc_core::ChannelArgs channel_args = grpc_core::CoreConfiguration::Get()
+                                            .channel_args_preconditioning()
+                                            .PreconditionChannelArgs(args);
   GRPC_API_TRACE(
       "grpc_server_config_fetcher_xds_create(notifier={on_serving_status_"
       "update=%p, user_data=%p}, args=%p)",
       3, (notifier.on_serving_status_update, notifier.user_data, args));
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_core::RefCountedPtr<grpc_core::XdsClient> xds_client =
-      grpc_core::XdsClient::GetOrCreate(args, &error);
-  grpc_channel_args_destroy(args);
-  if (error != GRPC_ERROR_NONE) {
+  auto xds_client = grpc_core::GrpcXdsClient::GetOrCreate(
+      channel_args, "XdsServerConfigFetcher");
+  if (!xds_client.ok()) {
     gpr_log(GPR_ERROR, "Failed to create xds client: %s",
-            grpc_error_std_string(error).c_str());
-    GRPC_ERROR_UNREF(error);
+            xds_client.status().ToString().c_str());
     return nullptr;
   }
-  if (xds_client->bootstrap()
+  if ((*xds_client)
+          ->bootstrap()
           .server_listener_resource_name_template()
           .empty()) {
     gpr_log(GPR_ERROR,
@@ -1311,5 +1353,6 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
             "file.");
     return nullptr;
   }
-  return new grpc_core::XdsServerConfigFetcher(std::move(xds_client), notifier);
+  return new grpc_core::XdsServerConfigFetcher(std::move(*xds_client),
+                                               notifier);
 }

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

@@ -0,0 +1,86 @@
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_EXT_XDS_XDS_TRANSPORT_H
+#define GRPC_CORE_EXT_XDS_XDS_TRANSPORT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/lib/gprpp/orphanable.h"
+
+namespace grpc_core {
+
+// A factory for creating new XdsTransport instances.
+class XdsTransportFactory : public InternallyRefCounted<XdsTransportFactory> {
+ public:
+  // Represents a transport for xDS communication (e.g., a gRPC channel).
+  class XdsTransport : public InternallyRefCounted<XdsTransport> {
+   public:
+    // Represents a bidi streaming RPC call.
+    class StreamingCall : public InternallyRefCounted<StreamingCall> {
+     public:
+      // An interface for handling events on a streaming call.
+      class EventHandler {
+       public:
+        virtual ~EventHandler() = default;
+
+        // Called when a SendMessage() operation completes.
+        virtual void OnRequestSent(bool ok) = 0;
+        // Called when a message is received on the stream.
+        virtual void OnRecvMessage(absl::string_view payload) = 0;
+        // Called when status is received on the stream.
+        virtual void OnStatusReceived(absl::Status status) = 0;
+      };
+
+      // Sends a message on the stream.  When the message has been sent,
+      // the EventHandler::OnRequestSent() method will be called.
+      // Only one message will be in flight at a time; subsequent
+      // messages will not be sent until this one is done.
+      virtual void SendMessage(std::string payload) = 0;
+    };
+
+    // Create a streaming call on this transport for the specified method.
+    // Events on the stream will be reported to event_handler.
+    virtual OrphanablePtr<StreamingCall> CreateStreamingCall(
+        const char* method,
+        std::unique_ptr<StreamingCall::EventHandler> event_handler) = 0;
+
+    // Resets connection backoff for the transport.
+    virtual void ResetBackoff() = 0;
+  };
+
+  // Creates a new transport for the specified server.
+  // The on_connectivity_failure callback will be invoked whenever there is
+  // a connectivity failure on the transport.
+  // *status will be set if there is an error creating the channel,
+  // although the returned channel must still accept calls (which may fail).
+  virtual OrphanablePtr<XdsTransport> Create(
+      const XdsBootstrap::XdsServer& server,
+      std::function<void(absl::Status)> on_connectivity_failure,
+      absl::Status* status) = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_TRANSPORT_H