grpc 1.69.0 → 1.70.1

data/src/core/util/matchers.h

@@ -91,20 +91,15 @@ class HeaderMatcher {
   // the corresponding StringMatcher::Type enum values, so that it's safe to
   // convert by casting when delegating to StringMatcher.
   static_assert(static_cast<StringMatcher::Type>(Type::kExact) ==
-                    StringMatcher::Type::kExact,
-                "");
+                StringMatcher::Type::kExact);
   static_assert(static_cast<StringMatcher::Type>(Type::kPrefix) ==
-                    StringMatcher::Type::kPrefix,
-                "");
+                StringMatcher::Type::kPrefix);
   static_assert(static_cast<StringMatcher::Type>(Type::kSuffix) ==
-                    StringMatcher::Type::kSuffix,
-                "");
+                StringMatcher::Type::kSuffix);
   static_assert(static_cast<StringMatcher::Type>(Type::kSafeRegex) ==
-                    StringMatcher::Type::kSafeRegex,
-                "");
+                StringMatcher::Type::kSafeRegex);
   static_assert(static_cast<StringMatcher::Type>(Type::kContains) ==
-                    StringMatcher::Type::kContains,
-                "");
+                StringMatcher::Type::kContains);
 
   // Creates HeaderMatcher instance. Returns error status on failure.
   static absl::StatusOr<HeaderMatcher> Create(absl::string_view name, Type type,

data/src/core/util/ref_counted.h

@@ -284,6 +284,7 @@ template <typename Child, typename Impl = PolymorphicRefCount,
 class RefCounted : public Impl {
  public:
   using RefCountedChildType = Child;
+  using RefCountedUnrefBehaviorType = UnrefBehavior;
 
   // Not copyable nor movable.
   RefCounted(const RefCounted&) = delete;

data/src/core/util/ref_counted_ptr.h

@@ -20,8 +20,8 @@
 #define GRPC_SRC_CORE_UTIL_REF_COUNTED_PTR_H
 
 #include <grpc/support/port_platform.h>
-#include <stddef.h>
 
+#include <cstddef>
 #include <iosfwd>
 #include <type_traits>
 #include <utility>

data/src/core/util/useful.h

@@ -1,5 +1,3 @@
-//
-//
 // Copyright 2015 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,8 +11,6 @@
 // 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_SRC_CORE_UTIL_USEFUL_H
 #define GRPC_SRC_CORE_UTIL_USEFUL_H
@@ -22,6 +18,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <cstddef>
+#include <limits>
 
 #include "absl/log/check.h"
 #include "absl/numeric/bits.h"
@@ -103,15 +100,16 @@ constexpr size_t HashPointer(T* p, size_t range) {
 }
 
 // Compute a+b.
-// If the result is greater than INT64_MAX, return INT64_MAX.
-// If the result is less than INT64_MIN, return INT64_MIN.
-inline int64_t SaturatingAdd(int64_t a, int64_t b) {
+// If the result is greater than MAX, return MAX.
+// If the result is less than MIN, return MIN.
+template <typename T>
+inline T SaturatingAdd(T a, T b) {
   if (a > 0) {
-    if (b > INT64_MAX - a) {
-      return INT64_MAX;
+    if (b > std::numeric_limits<T>::max() - a) {
+      return std::numeric_limits<T>::max();
     }
-  } else if (b < INT64_MIN - a) {
-    return INT64_MIN;
+  } else if (b < std::numeric_limits<T>::min() - a) {
+    return std::numeric_limits<T>::min();
   }
   return a + b;
 }

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

@@ -45,8 +45,11 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/load_balancing/ring_hash/ring_hash.h"
 #include "src/core/util/down_cast.h"
 #include "src/core/util/env.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/string.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/util/validation_errors.h"
@@ -72,6 +75,16 @@ bool XdsDualstackEndpointsEnabled() {
   return parse_succeeded && parsed_value;
 }
 
+// TODO(roth): Flip the default to false once this proves stable, then
+// remove it entirely at some point in the future.
+bool XdsEndpointHashKeyBackwardCompatEnabled() {
+  auto value = GetEnv("GRPC_XDS_ENDPOINT_HASH_KEY_BACKWARD_COMPAT");
+  if (!value.has_value()) return true;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
 void MaybeLogClusterLoadAssignment(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_endpoint_v3_ClusterLoadAssignment* cla) {
@@ -87,21 +100,22 @@ void MaybeLogClusterLoadAssignment(
   }
 }
 
-std::string GetProxyAddressFromMetadata(
-    const XdsResourceType::DecodeContext& context,
-    const envoy_config_core_v3_Metadata* metadata, ValidationErrors* errors) {
-  if (XdsHttpConnectEnabled() && metadata != nullptr) {
-    XdsMetadataMap metadata_map =
-        ParseXdsMetadataMap(context, metadata, errors);
-    auto* proxy_address_entry =
-        metadata_map.Find("envoy.http11_proxy_transport_socket.proxy_address");
-    if (proxy_address_entry != nullptr &&
-        proxy_address_entry->type() == XdsAddressMetadataValue::Type()) {
-      return DownCast<const XdsAddressMetadataValue*>(proxy_address_entry)
-          ->address();
-    }
-  }
-  return "";
+std::string GetProxyAddressFromMetadata(const XdsMetadataMap& metadata_map) {
+  auto* proxy_address_entry = metadata_map.FindType<XdsAddressMetadataValue>(
+      "envoy.http11_proxy_transport_socket.proxy_address");
+  if (proxy_address_entry == nullptr) return "";
+  return proxy_address_entry->address();
+}
+
+std::string GetHashKeyFromMetadata(const XdsMetadataMap& metadata_map) {
+  auto* hash_key_entry =
+      metadata_map.FindType<XdsStructMetadataValue>("envoy.lb");
+  if (hash_key_entry == nullptr) return "";
+  ValidationErrors unused_errors;
+  return LoadJsonObjectField<std::string>(hash_key_entry->json().object(),
+                                          JsonArgs(), "hash_key",
+                                          &unused_errors)
+      .value_or("");
 }
 
 absl::optional<EndpointAddresses> EndpointAddressesParse(
@@ -126,9 +140,19 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
     }
   }
   // metadata
-  std::string proxy_address = GetProxyAddressFromMetadata(
-      context, envoy_config_endpoint_v3_LbEndpoint_metadata(lb_endpoint),
-      errors);
+  std::string proxy_address;
+  std::string hash_key;
+  if (XdsHttpConnectEnabled() || !XdsEndpointHashKeyBackwardCompatEnabled()) {
+    XdsMetadataMap metadata_map = ParseXdsMetadataMap(
+        context, envoy_config_endpoint_v3_LbEndpoint_metadata(lb_endpoint),
+        errors);
+    if (XdsHttpConnectEnabled()) {
+      proxy_address = GetProxyAddressFromMetadata(metadata_map);
+    }
+    if (!XdsEndpointHashKeyBackwardCompatEnabled()) {
+      hash_key = GetHashKeyFromMetadata(metadata_map);
+    }
+  }
   // endpoint
   std::vector<grpc_resolved_address> addresses;
   absl::string_view hostname;
@@ -177,6 +201,9 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
   } else if (!locality_proxy_address.empty()) {
     args = args.Set(GRPC_ARG_XDS_HTTP_PROXY, locality_proxy_address);
   }
+  if (!hash_key.empty()) {
+    args = args.Set(GRPC_ARG_RING_HASH_ENDPOINT_HASH_KEY, hash_key);
+  }
   return EndpointAddresses(addresses, args);
 }
 
@@ -231,11 +258,15 @@ absl::optional<ParsedLocality> LocalityParse(
   parsed_locality.locality.name = MakeRefCounted<XdsLocalityName>(
       std::move(region), std::move(zone), std::move(sub_zone));
   // metadata
-  std::string proxy_address = GetProxyAddressFromMetadata(
-      context,
-      envoy_config_endpoint_v3_LocalityLbEndpoints_metadata(
-          locality_lb_endpoints),
-      errors);
+  std::string proxy_address;
+  if (XdsHttpConnectEnabled()) {
+    XdsMetadataMap metadata_map = ParseXdsMetadataMap(
+        context,
+        envoy_config_endpoint_v3_LocalityLbEndpoints_metadata(
+            locality_lb_endpoints),
+        errors);
+    proxy_address = GetProxyAddressFromMetadata(metadata_map);
+  }
   // lb_endpoints
   size_t size;
   const envoy_config_endpoint_v3_LbEndpoint* const* lb_endpoints =

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

@@ -60,6 +60,14 @@ class XdsMetadataMap {
 
   const XdsMetadataValue* Find(absl::string_view key) const;
 
+  template <typename T>
+  const T* FindType(absl::string_view key) const {
+    auto it = map_.find(key);
+    if (it == map_.end()) return nullptr;
+    if (it->second->type() != T::Type()) return nullptr;
+    return DownCast<const T*>(it->second.get());
+  }
+
   bool empty() const { return map_.empty(); }
   size_t size() const { return map_.size(); }
 

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

@@ -16,62 +16,16 @@
 
 #include "src/core/xds/xds_client/xds_api.h"
 
-#include <grpc/status.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/time.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <set>
-#include <string>
-#include <vector>
-
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/strip.h"
-#include "envoy/config/core/v3/base.upb.h"
-#include "envoy/config/endpoint/v3/load_report.upb.h"
-#include "envoy/service/discovery/v3/discovery.upb.h"
-#include "envoy/service/discovery/v3/discovery.upbdefs.h"
-#include "envoy/service/load_stats/v3/lrs.upb.h"
-#include "envoy/service/load_stats/v3/lrs.upbdefs.h"
-#include "envoy/service/status/v3/csds.upb.h"
-#include "google/protobuf/any.upb.h"
-#include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
-#include "google/protobuf/timestamp.upb.h"
-#include "google/rpc/status.upb.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/upb_utils.h"
-#include "src/core/xds/xds_client/xds_client.h"
 #include "upb/base/string_view.h"
 #include "upb/mem/arena.hpp"
-#include "upb/reflection/def.h"
-#include "upb/text/encode.h"
-
-// IWYU pragma: no_include "upb/msg_internal.h"
 
 namespace grpc_core {
 
-XdsApi::XdsApi(XdsClient* client, TraceFlag* tracer,
-               const XdsBootstrap::Node* node, upb::DefPool* def_pool,
-               std::string user_agent_name, std::string user_agent_version)
-    : client_(client),
-      tracer_(tracer),
-      node_(node),
-      def_pool_(def_pool),
-      user_agent_name_(std::move(user_agent_name)),
-      user_agent_version_(std::move(user_agent_version)) {}
-
 namespace {
 
-struct XdsApiContext {
-  XdsClient* client;
-  TraceFlag* tracer;
-  upb_DefPool* def_pool;
-  upb_Arena* arena;
-};
-
 void PopulateMetadataValue(google_protobuf_Value* value_pb, const Json& value,
                            upb_Arena* arena);
 
@@ -125,37 +79,8 @@ void PopulateMetadataValue(google_protobuf_Value* value_pb, const Json& value,
   }
 }
 
-void MaybeLogDiscoveryRequest(
-    const XdsApiContext& context,
-    const envoy_service_discovery_v3_DiscoveryRequest* request) {
-  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
-    const upb_MessageDef* msg_type =
-        envoy_service_discovery_v3_DiscoveryRequest_getmsgdef(context.def_pool);
-    char buf[10240];
-    upb_TextEncode(reinterpret_cast<const upb_Message*>(request), msg_type,
-                   nullptr, 0, buf, sizeof(buf));
-    VLOG(2) << "[xds_client " << context.client
-            << "] constructed ADS request: " << buf;
-  }
-}
-
-std::string SerializeDiscoveryRequest(
-    const XdsApiContext& context,
-    envoy_service_discovery_v3_DiscoveryRequest* request) {
-  size_t output_length;
-  char* output = envoy_service_discovery_v3_DiscoveryRequest_serialize(
-      request, context.arena, &output_length);
-  return std::string(output, output_length);
-}
-
 }  // namespace
 
-void XdsApi::PopulateNode(envoy_config_core_v3_Node* node_msg,
-                          upb_Arena* arena) {
-  PopulateXdsNode(node_, user_agent_name_, user_agent_version_, node_msg,
-                  arena);
-}
-
 void PopulateXdsNode(const XdsBootstrap::Node* node,
                      absl::string_view user_agent_name,
                      absl::string_view user_agent_version,
@@ -202,152 +127,4 @@ void PopulateXdsNode(const XdsBootstrap::Node* node,
       arena);
 }
 
-std::string XdsApi::CreateAdsRequest(
-    absl::string_view type_url, absl::string_view version,
-    absl::string_view nonce, const std::vector<std::string>& resource_names,
-    absl::Status status, bool populate_node) {
-  upb::Arena arena;
-  const XdsApiContext context = {client_, tracer_, def_pool_->ptr(),
-                                 arena.ptr()};
-  // Create a request.
-  envoy_service_discovery_v3_DiscoveryRequest* request =
-      envoy_service_discovery_v3_DiscoveryRequest_new(arena.ptr());
-  // Set type_url.
-  std::string type_url_str = absl::StrCat("type.googleapis.com/", type_url);
-  envoy_service_discovery_v3_DiscoveryRequest_set_type_url(
-      request, StdStringToUpbString(type_url_str));
-  // Set version_info.
-  if (!version.empty()) {
-    envoy_service_discovery_v3_DiscoveryRequest_set_version_info(
-        request, StdStringToUpbString(version));
-  }
-  // Set nonce.
-  if (!nonce.empty()) {
-    envoy_service_discovery_v3_DiscoveryRequest_set_response_nonce(
-        request, StdStringToUpbString(nonce));
-  }
-  // Set error_detail if it's a NACK.
-  std::string error_string_storage;
-  if (!status.ok()) {
-    google_rpc_Status* error_detail =
-        envoy_service_discovery_v3_DiscoveryRequest_mutable_error_detail(
-            request, arena.ptr());
-    // Hard-code INVALID_ARGUMENT as the status code.
-    // TODO(roth): If at some point we decide we care about this value,
-    // we could attach a status code to the individual errors where we
-    // generate them in the parsing code, and then use that here.
-    google_rpc_Status_set_code(error_detail, GRPC_STATUS_INVALID_ARGUMENT);
-    // Error description comes from the status that was passed in.
-    error_string_storage = std::string(status.message());
-    upb_StringView error_description =
-        StdStringToUpbString(error_string_storage);
-    google_rpc_Status_set_message(error_detail, error_description);
-  }
-  // Populate node.
-  if (populate_node) {
-    envoy_config_core_v3_Node* node_msg =
-        envoy_service_discovery_v3_DiscoveryRequest_mutable_node(request,
-                                                                 arena.ptr());
-    PopulateNode(node_msg, arena.ptr());
-    envoy_config_core_v3_Node_add_client_features(
-        node_msg, upb_StringView_FromString("xds.config.resource-in-sotw"),
-        context.arena);
-  }
-  // Add resource_names.
-  for (const std::string& resource_name : resource_names) {
-    envoy_service_discovery_v3_DiscoveryRequest_add_resource_names(
-        request, StdStringToUpbString(resource_name), arena.ptr());
-  }
-  MaybeLogDiscoveryRequest(context, request);
-  return SerializeDiscoveryRequest(context, request);
-}
-
-namespace {
-
-void MaybeLogDiscoveryResponse(
-    const XdsApiContext& context,
-    const envoy_service_discovery_v3_DiscoveryResponse* response) {
-  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
-    const upb_MessageDef* msg_type =
-        envoy_service_discovery_v3_DiscoveryResponse_getmsgdef(
-            context.def_pool);
-    char buf[10240];
-    upb_TextEncode(reinterpret_cast<const upb_Message*>(response), msg_type,
-                   nullptr, 0, buf, sizeof(buf));
-    VLOG(2) << "[xds_client " << context.client
-            << "] received response: " << buf;
-  }
-}
-
-}  // namespace
-
-absl::Status XdsApi::ParseAdsResponse(absl::string_view encoded_response,
-                                      AdsResponseParserInterface* parser) {
-  upb::Arena arena;
-  const XdsApiContext context = {client_, tracer_, def_pool_->ptr(),
-                                 arena.ptr()};
-  // Decode the response.
-  const envoy_service_discovery_v3_DiscoveryResponse* response =
-      envoy_service_discovery_v3_DiscoveryResponse_parse(
-          encoded_response.data(), encoded_response.size(), arena.ptr());
-  // If decoding fails, report a fatal error and return.
-  if (response == nullptr) {
-    return absl::InvalidArgumentError("Can't decode DiscoveryResponse.");
-  }
-  MaybeLogDiscoveryResponse(context, response);
-  // Report the type_url, version, nonce, and number of resources to the parser.
-  AdsResponseParserInterface::AdsResponseFields fields;
-  fields.type_url = std::string(absl::StripPrefix(
-      UpbStringToAbsl(
-          envoy_service_discovery_v3_DiscoveryResponse_type_url(response)),
-      "type.googleapis.com/"));
-  fields.version = UpbStringToStdString(
-      envoy_service_discovery_v3_DiscoveryResponse_version_info(response));
-  fields.nonce = UpbStringToStdString(
-      envoy_service_discovery_v3_DiscoveryResponse_nonce(response));
-  size_t num_resources;
-  const google_protobuf_Any* const* resources =
-      envoy_service_discovery_v3_DiscoveryResponse_resources(response,
-                                                             &num_resources);
-  fields.num_resources = num_resources;
-  absl::Status status = parser->ProcessAdsResponseFields(std::move(fields));
-  if (!status.ok()) return status;
-  // Process each resource.
-  for (size_t i = 0; i < num_resources; ++i) {
-    absl::string_view type_url = absl::StripPrefix(
-        UpbStringToAbsl(google_protobuf_Any_type_url(resources[i])),
-        "type.googleapis.com/");
-    absl::string_view serialized_resource =
-        UpbStringToAbsl(google_protobuf_Any_value(resources[i]));
-    // Unwrap Resource messages, if so wrapped.
-    absl::string_view resource_name;
-    if (type_url == "envoy.service.discovery.v3.Resource") {
-      const auto* resource_wrapper = envoy_service_discovery_v3_Resource_parse(
-          serialized_resource.data(), serialized_resource.size(), arena.ptr());
-      if (resource_wrapper == nullptr) {
-        parser->ResourceWrapperParsingFailed(
-            i, "Can't decode Resource proto wrapper");
-        continue;
-      }
-      const auto* resource =
-          envoy_service_discovery_v3_Resource_resource(resource_wrapper);
-      if (resource == nullptr) {
-        parser->ResourceWrapperParsingFailed(
-            i, "No resource present in Resource proto wrapper");
-        continue;
-      }
-      type_url = absl::StripPrefix(
-          UpbStringToAbsl(google_protobuf_Any_type_url(resource)),
-          "type.googleapis.com/");
-      serialized_resource =
-          UpbStringToAbsl(google_protobuf_Any_value(resource));
-      resource_name = UpbStringToAbsl(
-          envoy_service_discovery_v3_Resource_name(resource_wrapper));
-    }
-    parser->ParseResource(context.arena, i, type_url, resource_name,
-                          serialized_resource);
-  }
-  return absl::OkStatus();
-}
-
 }  // namespace grpc_core

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

@@ -17,145 +17,13 @@
 #ifndef GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_API_H
 #define GRPC_SRC_CORE_XDS_XDS_CLIENT_XDS_API_H
 
-#include <grpc/support/port_platform.h>
-#include <stddef.h>
-
-#include <map>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "envoy/admin/v3/config_dump_shared.upb.h"
-#include "envoy/service/status/v3/csds.upb.h"
-#include "src/core/lib/debug/trace.h"
-#include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/time.h"
+#include "envoy/config/core/v3/base.upb.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
-#include "src/core/xds/xds_client/xds_locality.h"
 #include "upb/mem/arena.h"
-#include "upb/reflection/def.hpp"
 
 namespace grpc_core {
 
-class XdsClient;
-
-// TODO(roth): When we have time, remove this class and move its
-// functionality directly inside of XdsClient.
-class XdsApi final {
- public:
-  // Interface defined by caller and passed to ParseAdsResponse().
-  class AdsResponseParserInterface {
-   public:
-    struct AdsResponseFields {
-      std::string type_url;
-      std::string version;
-      std::string nonce;
-      size_t num_resources;
-    };
-
-    virtual ~AdsResponseParserInterface() = default;
-
-    // Called when the top-level ADS fields are parsed.
-    // If this returns non-OK, parsing will stop, and the individual
-    // resources will not be processed.
-    virtual absl::Status ProcessAdsResponseFields(AdsResponseFields fields) = 0;
-
-    // Called to parse each individual resource in the ADS response.
-    // Note that resource_name is non-empty only when the resource was
-    // wrapped in a Resource wrapper proto.
-    virtual void ParseResource(upb_Arena* arena, size_t idx,
-                               absl::string_view type_url,
-                               absl::string_view resource_name,
-                               absl::string_view serialized_resource) = 0;
-
-    // Called when a resource is wrapped in a Resource wrapper proto but
-    // we fail to parse the Resource wrapper.
-    virtual void ResourceWrapperParsingFailed(size_t idx,
-                                              absl::string_view message) = 0;
-  };
-
-  // The metadata of the xDS resource; used by the xDS config dump.
-  struct ResourceMetadata {
-    // Resource status from the view of a xDS client, which tells the
-    // synchronization status between the xDS client and the xDS server.
-    enum ClientResourceStatus {
-      // Client requested this resource but hasn't received any update from
-      // management server. The client will not fail requests, but will queue
-      // them
-      // until update arrives or the client times out waiting for the resource.
-      REQUESTED = 1,
-      // This resource has been requested by the client but has either not been
-      // delivered by the server or was previously delivered by the server and
-      // then subsequently removed from resources provided by the server.
-      DOES_NOT_EXIST,
-      // Client received this resource and replied with ACK.
-      ACKED,
-      // Client received this resource and replied with NACK.
-      NACKED
-    };
-
-    // The client status of this resource.
-    ClientResourceStatus client_status = REQUESTED;
-    // The serialized bytes of the last successfully updated raw xDS resource.
-    std::string serialized_proto;
-    // The timestamp when the resource was last successfully updated.
-    Timestamp update_time;
-    // The last successfully updated version of the resource.
-    std::string version;
-    // The rejected version string of the last failed update attempt.
-    std::string failed_version;
-    // Details about the last failed update attempt.
-    std::string failed_details;
-    // Timestamp of the last failed update attempt.
-    Timestamp failed_update_time;
-  };
-  static_assert(static_cast<ResourceMetadata::ClientResourceStatus>(
-                    envoy_admin_v3_REQUESTED) ==
-                    ResourceMetadata::ClientResourceStatus::REQUESTED,
-                "");
-  static_assert(static_cast<ResourceMetadata::ClientResourceStatus>(
-                    envoy_admin_v3_DOES_NOT_EXIST) ==
-                    ResourceMetadata::ClientResourceStatus::DOES_NOT_EXIST,
-                "");
-  static_assert(static_cast<ResourceMetadata::ClientResourceStatus>(
-                    envoy_admin_v3_ACKED) ==
-                    ResourceMetadata::ClientResourceStatus::ACKED,
-                "");
-  static_assert(static_cast<ResourceMetadata::ClientResourceStatus>(
-                    envoy_admin_v3_NACKED) ==
-                    ResourceMetadata::ClientResourceStatus::NACKED,
-                "");
-
-  XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node,
-         upb::DefPool* def_pool, std::string user_agent_name,
-         std::string user_agent_version);
-
-  // Creates an ADS request.
-  std::string CreateAdsRequest(absl::string_view type_url,
-                               absl::string_view version,
-                               absl::string_view nonce,
-                               const std::vector<std::string>& resource_names,
-                               absl::Status status, bool populate_node);
-
-  // Returns non-OK when failing to deserialize response message.
-  // Otherwise, all events are reported to the parser.
-  absl::Status ParseAdsResponse(absl::string_view encoded_response,
-                                AdsResponseParserInterface* parser);
-
-  void PopulateNode(envoy_config_core_v3_Node* node_msg, upb_Arena* arena);
-
- private:
-  XdsClient* client_;
-  TraceFlag* tracer_;
-  const XdsBootstrap::Node* node_;  // Do not own.
-  upb::DefPool* def_pool_;          // Do not own.
-  const std::string user_agent_name_;
-  const std::string user_agent_version_;
-};
-
 void PopulateXdsNode(const XdsBootstrap::Node* node,
                      absl::string_view user_agent_name,
                      absl::string_view user_agent_version,