grpc 1.44.0.pre2 → 1.45.0

data/src/core/ext/upbdefs-generated/xds/type/matcher/v3/string.upbdefs.c

@@ -0,0 +1,52 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     xds/type/matcher/v3/string.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#include "upb/def.h"
+#include "xds/type/matcher/v3/string.upbdefs.h"
+#include "xds/type/matcher/v3/string.upb.h"
+
+extern _upb_DefPool_Init xds_type_matcher_v3_regex_proto_upbdefinit;
+extern _upb_DefPool_Init validate_validate_proto_upbdefinit;
+static const char descriptor[593] = {'\n', ' ', 'x', 'd', 's', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', '/', 's', 't', 'r', 
+'i', 'n', 'g', '.', 'p', 'r', 'o', 't', 'o', '\022', '\023', 'x', 'd', 's', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 
+'e', 'r', '.', 'v', '3', '\032', '\037', 'x', 'd', 's', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', 
+'3', '/', 'r', 'e', 'g', 'e', 'x', '.', 'p', 'r', 'o', 't', 'o', '\032', '\027', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '/', 'v', 
+'a', 'l', 'i', 'd', 'a', 't', 'e', '.', 'p', 'r', 'o', 't', 'o', '\"', '\231', '\002', '\n', '\r', 'S', 't', 'r', 'i', 'n', 'g', 'M', 
+'a', 't', 'c', 'h', 'e', 'r', '\022', '\026', '\n', '\005', 'e', 'x', 'a', 'c', 't', '\030', '\001', ' ', '\001', '(', '\t', 'H', '\000', 'R', '\005', 
+'e', 'x', 'a', 'c', 't', '\022', '!', '\n', '\006', 'p', 'r', 'e', 'f', 'i', 'x', '\030', '\002', ' ', '\001', '(', '\t', 'B', '\007', '\372', 'B', 
+'\004', 'r', '\002', '\020', '\001', 'H', '\000', 'R', '\006', 'p', 'r', 'e', 'f', 'i', 'x', '\022', '!', '\n', '\006', 's', 'u', 'f', 'f', 'i', 'x', 
+'\030', '\003', ' ', '\001', '(', '\t', 'B', '\007', '\372', 'B', '\004', 'r', '\002', '\020', '\001', 'H', '\000', 'R', '\006', 's', 'u', 'f', 'f', 'i', 'x', 
+'\022', 'L', '\n', '\n', 's', 'a', 'f', 'e', '_', 'r', 'e', 'g', 'e', 'x', '\030', '\005', ' ', '\001', '(', '\013', '2', '!', '.', 'x', 'd', 
+'s', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', '.', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 
+'t', 'c', 'h', 'e', 'r', 'B', '\010', '\372', 'B', '\005', '\212', '\001', '\002', '\020', '\001', 'H', '\000', 'R', '\t', 's', 'a', 'f', 'e', 'R', 'e', 
+'g', 'e', 'x', '\022', '%', '\n', '\010', 'c', 'o', 'n', 't', 'a', 'i', 'n', 's', '\030', '\007', ' ', '\001', '(', '\t', 'B', '\007', '\372', 'B', 
+'\004', 'r', '\002', '\020', '\001', 'H', '\000', 'R', '\010', 'c', 'o', 'n', 't', 'a', 'i', 'n', 's', '\022', '\037', '\n', '\013', 'i', 'g', 'n', 'o', 
+'r', 'e', '_', 'c', 'a', 's', 'e', '\030', '\006', ' ', '\001', '(', '\010', 'R', '\n', 'i', 'g', 'n', 'o', 'r', 'e', 'C', 'a', 's', 'e', 
+'B', '\024', '\n', '\r', 'm', 'a', 't', 'c', 'h', '_', 'p', 'a', 't', 't', 'e', 'r', 'n', '\022', '\003', '\370', 'B', '\001', '\"', ']', '\n', 
+'\021', 'L', 'i', 's', 't', 'S', 't', 'r', 'i', 'n', 'g', 'M', 'a', 't', 'c', 'h', 'e', 'r', '\022', 'H', '\n', '\010', 'p', 'a', 't', 
+'t', 'e', 'r', 'n', 's', '\030', '\001', ' ', '\003', '(', '\013', '2', '\"', '.', 'x', 'd', 's', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 
+'t', 'c', 'h', 'e', 'r', '.', 'v', '3', '.', 'S', 't', 'r', 'i', 'n', 'g', 'M', 'a', 't', 'c', 'h', 'e', 'r', 'B', '\010', '\372', 
+'B', '\005', '\222', '\001', '\002', '\010', '\001', 'R', '\010', 'p', 'a', 't', 't', 'e', 'r', 'n', 's', 'B', '[', '\n', '\036', 'c', 'o', 'm', '.', 
+'g', 'i', 't', 'h', 'u', 'b', '.', 'x', 'd', 's', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', 
+'3', 'B', '\013', 'S', 't', 'r', 'i', 'n', 'g', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', '*', 'g', 'i', 't', 'h', 'u', 'b', '.', 
+'c', 'o', 'm', '/', 'c', 'n', 'c', 'f', '/', 'x', 'd', 's', '/', 'g', 'o', '/', 'x', 'd', 's', '/', 't', 'y', 'p', 'e', '/', 
+'m', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', 'b', '\006', 'p', 'r', 'o', 't', 'o', '3', 
+};
+
+static _upb_DefPool_Init *deps[3] = {
+  &xds_type_matcher_v3_regex_proto_upbdefinit,
+  &validate_validate_proto_upbdefinit,
+  NULL
+};
+
+_upb_DefPool_Init xds_type_matcher_v3_string_proto_upbdefinit = {
+  deps,
+  &xds_type_matcher_v3_string_proto_upb_file_layout,
+  "xds/type/matcher/v3/string.proto",
+  UPB_STRINGVIEW_INIT(descriptor, 593)
+};

data/src/core/ext/upbdefs-generated/xds/type/matcher/v3/string.upbdefs.h

@@ -0,0 +1,40 @@
+/* This file was generated by upbc (the upb compiler) from the input
+ * file:
+ *
+ *     xds/type/matcher/v3/string.proto
+ *
+ * Do not edit -- your changes will be discarded when the file is
+ * regenerated. */
+
+#ifndef XDS_TYPE_MATCHER_V3_STRING_PROTO_UPBDEFS_H_
+#define XDS_TYPE_MATCHER_V3_STRING_PROTO_UPBDEFS_H_
+
+#include "upb/def.h"
+#include "upb/port_def.inc"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "upb/def.h"
+
+#include "upb/port_def.inc"
+
+extern _upb_DefPool_Init xds_type_matcher_v3_string_proto_upbdefinit;
+
+UPB_INLINE const upb_MessageDef *xds_type_matcher_v3_StringMatcher_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &xds_type_matcher_v3_string_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "xds.type.matcher.v3.StringMatcher");
+}
+
+UPB_INLINE const upb_MessageDef *xds_type_matcher_v3_ListStringMatcher_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &xds_type_matcher_v3_string_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "xds.type.matcher.v3.ListStringMatcher");
+}
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif  /* XDS_TYPE_MATCHER_V3_STRING_PROTO_UPBDEFS_H_ */

data/src/core/ext/upbdefs-generated/xds/type/v3/typed_struct.upbdefs.c

@@ -10,8 +10,8 @@
 #include "xds/type/v3/typed_struct.upbdefs.h"
 #include "xds/type/v3/typed_struct.upb.h"
 
-extern upb_def_init validate_validate_proto_upbdefinit;
-extern upb_def_init google_protobuf_struct_proto_upbdefinit;
+extern _upb_DefPool_Init validate_validate_proto_upbdefinit;
+extern _upb_DefPool_Init google_protobuf_struct_proto_upbdefinit;
 static const char descriptor[279] = {'\n', '\036', 'x', 'd', 's', '/', 't', 'y', 'p', 'e', '/', 'v', '3', '/', 't', 'y', 'p', 'e', 'd', '_', 's', 't', 'r', 'u', 'c', 
 't', '.', 'p', 'r', 'o', 't', 'o', '\022', '\013', 'x', 'd', 's', '.', 't', 'y', 'p', 'e', '.', 'v', '3', '\032', '\027', 'v', 'a', 'l', 
 'i', 'd', 'a', 't', 'e', '/', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '.', 'p', 'r', 'o', 't', 'o', '\032', '\034', 'g', 'o', 'o', 
@@ -26,15 +26,15 @@ static const char descriptor[279] = {'\n', '\036', 'x', 'd', 's', '/', 't', 'y',
 'o', 't', 'o', '3', 
 };
 
-static upb_def_init *deps[3] = {
+static _upb_DefPool_Init *deps[3] = {
   &validate_validate_proto_upbdefinit,
   &google_protobuf_struct_proto_upbdefinit,
   NULL
 };
 
-upb_def_init xds_type_v3_typed_struct_proto_upbdefinit = {
+_upb_DefPool_Init xds_type_v3_typed_struct_proto_upbdefinit = {
   deps,
   &xds_type_v3_typed_struct_proto_upb_file_layout,
   "xds/type/v3/typed_struct.proto",
-  UPB_STRVIEW_INIT(descriptor, 279)
+  UPB_STRINGVIEW_INIT(descriptor, 279)
 };

data/src/core/ext/upbdefs-generated/xds/type/v3/typed_struct.upbdefs.h

@@ -19,11 +19,11 @@ extern "C" {
 
 #include "upb/port_def.inc"
 
-extern upb_def_init xds_type_v3_typed_struct_proto_upbdefinit;
+extern _upb_DefPool_Init xds_type_v3_typed_struct_proto_upbdefinit;
 
-UPB_INLINE const upb_msgdef *xds_type_v3_TypedStruct_getmsgdef(upb_symtab *s) {
-  _upb_symtab_loaddefinit(s, &xds_type_v3_typed_struct_proto_upbdefinit);
-  return upb_symtab_lookupmsg(s, "xds.type.v3.TypedStruct");
+UPB_INLINE const upb_MessageDef *xds_type_v3_TypedStruct_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &xds_type_v3_typed_struct_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "xds.type.v3.TypedStruct");
 }
 
 #ifdef __cplusplus

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

@@ -58,7 +58,7 @@ std::string FileWatcherCertificateProviderFactory::Config::ToString() const {
         absl::StrFormat("ca_certificate_file=\"%s\", ", root_cert_file_));
   }
   parts.push_back(
-      absl::StrFormat("refresh_interval=%ldms}", refresh_interval_ms_));
+      absl::StrFormat("refresh_interval=%ldms}", refresh_interval_.millis()));
   return absl::StrJoin(parts, "");
 }
 
@@ -91,8 +91,8 @@ FileWatcherCertificateProviderFactory::Config::Parse(const Json& config_json,
   }
   if (!ParseJsonObjectFieldAsDuration(
           config_json.object_value(), "refresh_interval",
-          &config->refresh_interval_ms_, &error_list, false)) {
-    config->refresh_interval_ms_ = 10 * 60 * 1000;  // 10 minutes default
+          &config->refresh_interval_, &error_list, false)) {
+    config->refresh_interval_ = Duration::Minutes(10);  // 10 minutes default
   }
   if (!error_list.empty()) {
     *error = GRPC_ERROR_CREATE_FROM_VECTOR(
@@ -131,7 +131,7 @@ FileWatcherCertificateProviderFactory::CreateCertificateProvider(
       file_watcher_config->private_key_file(),
       file_watcher_config->identity_cert_file(),
       file_watcher_config->root_cert_file(),
-      file_watcher_config->refresh_interval_ms() / GPR_MS_PER_SEC);
+      file_watcher_config->refresh_interval().millis() / GPR_MS_PER_SEC);
 }
 
 void FileWatcherCertificateProviderInit() {

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

@@ -45,13 +45,13 @@ class FileWatcherCertificateProviderFactory
 
     const std::string& root_cert_file() const { return root_cert_file_; }
 
-    grpc_millis refresh_interval_ms() const { return refresh_interval_ms_; }
+    Duration refresh_interval() const { return refresh_interval_; }
 
    private:
     std::string identity_cert_file_;
     std::string private_key_file_;
     std::string root_cert_file_;
-    grpc_millis refresh_interval_ms_;
+    Duration refresh_interval_;
   };
 
   const char* name() const override;

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

@@ -27,6 +27,7 @@
 #include "upb/upb.hpp"
 
 #include "src/core/ext/xds/certificate_provider_store.h"
+#include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/lib/debug/trace.h"
 
 namespace grpc_core {
@@ -38,9 +39,10 @@ class XdsClient;
 // passing through XdsApi code, maybe via the AdsResponseParser.
 struct XdsEncodingContext {
   XdsClient* client;  // Used only for logging. Unsafe for dereferencing.
+  const XdsBootstrap::XdsServer& server;
   TraceFlag* tracer;
-  upb_symtab* symtab;
-  upb_arena* arena;
+  upb_DefPool* symtab;
+  upb_Arena* arena;
   bool use_v3;
   const CertificateProviderStore::PluginDefinitionMap*
       certificate_provider_definition_map;
@@ -48,15 +50,15 @@ struct XdsEncodingContext {
 
 // Works for both std::string and absl::string_view.
 template <typename T>
-inline upb_strview StdStringToUpbString(const T& str) {
-  return upb_strview_make(str.data(), str.size());
+inline upb_StringView StdStringToUpbString(const T& str) {
+  return upb_StringView_FromDataAndSize(str.data(), str.size());
 }
 
-inline absl::string_view UpbStringToAbsl(const upb_strview& str) {
+inline absl::string_view UpbStringToAbsl(const upb_StringView& str) {
   return absl::string_view(str.data, str.size);
 }
 
-inline std::string UpbStringToStdString(const upb_strview& str) {
+inline std::string UpbStringToStdString(const upb_StringView& str) {
   return std::string(str.data, str.size);
 }
 

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

@@ -57,7 +57,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
-#include "src/core/lib/slice/slice_utils.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -187,12 +187,12 @@ void PopulateBuildVersion(const XdsEncodingContext& context,
                           envoy_config_core_v3_Node* node_msg,
                           const std::string& build_version) {
   std::string encoded_build_version = EncodeStringField(5, build_version);
-  // TODO(roth): This should use upb_msg_addunknown(), but that API is
+  // TODO(roth): This should use upb_Message_AddUnknown(), but that API is
   // broken in the current version of upb, so we're using the internal
   // API for now.  Change this once we upgrade to a version of upb that
   // fixes this bug.
-  _upb_msg_addunknown(node_msg, encoded_build_version.data(),
-                      encoded_build_version.size(), context.arena);
+  _upb_Message_AddUnknown(node_msg, encoded_build_version.data(),
+                          encoded_build_version.size(), context.arena);
 }
 
 void PopulateNode(const XdsEncodingContext& context,
@@ -241,7 +241,8 @@ void PopulateNode(const XdsEncodingContext& context,
   envoy_config_core_v3_Node_set_user_agent_version(
       node_msg, StdStringToUpbString(user_agent_version));
   envoy_config_core_v3_Node_add_client_features(
-      node_msg, upb_strview_makez("envoy.lb.does_not_support_overprovisioning"),
+      node_msg,
+      upb_StringView_FromString("envoy.lb.does_not_support_overprovisioning"),
       context.arena);
 }
 
@@ -250,10 +251,10 @@ void MaybeLogDiscoveryRequest(
     const envoy_service_discovery_v3_DiscoveryRequest* request) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_service_discovery_v3_DiscoveryRequest_getmsgdef(context.symtab);
     char buf[10240];
-    upb_text_encode(request, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(request, msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] constructed ADS request: %s",
             context.client, buf);
   }
@@ -277,6 +278,7 @@ grpc_slice XdsApi::CreateAdsRequest(
     bool populate_node) {
   upb::Arena arena;
   const XdsEncodingContext context = {client_,
+                                      server,
                                       tracer_,
                                       symtab_->ptr(),
                                       arena.ptr(),
@@ -312,7 +314,8 @@ grpc_slice XdsApi::CreateAdsRequest(
     google_rpc_Status_set_code(error_detail, GRPC_STATUS_INVALID_ARGUMENT);
     // Error description comes from the error that was passed in.
     error_string_storage = grpc_error_std_string(error);
-    upb_strview error_description = StdStringToUpbString(error_string_storage);
+    upb_StringView error_description =
+        StdStringToUpbString(error_string_storage);
     google_rpc_Status_set_message(error_detail, error_description);
     GRPC_ERROR_UNREF(error);
   }
@@ -340,10 +343,10 @@ void MaybeLogDiscoveryResponse(
     const envoy_service_discovery_v3_DiscoveryResponse* response) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_service_discovery_v3_DiscoveryResponse_getmsgdef(context.symtab);
     char buf[10240];
-    upb_text_encode(response, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(response, msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] received response: %s", context.client,
             buf);
   }
@@ -356,6 +359,7 @@ absl::Status XdsApi::ParseAdsResponse(const XdsBootstrap::XdsServer& server,
                                       AdsResponseParserInterface* parser) {
   upb::Arena arena;
   const XdsEncodingContext context = {client_,
+                                      server,
                                       tracer_,
                                       symtab_->ptr(),
                                       arena.ptr(),
@@ -407,10 +411,10 @@ void MaybeLogLrsRequest(
     const envoy_service_load_stats_v3_LoadStatsRequest* request) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_service_load_stats_v3_LoadStatsRequest_getmsgdef(context.symtab);
     char buf[10240];
-    upb_text_encode(request, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(request, msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] constructed LRS request: %s",
             context.client, buf);
   }
@@ -431,6 +435,7 @@ grpc_slice XdsApi::CreateLrsInitialRequest(
     const XdsBootstrap::XdsServer& server) {
   upb::Arena arena;
   const XdsEncodingContext context = {client_,
+                                      server,
                                       tracer_,
                                       symtab_->ptr(),
                                       arena.ptr(),
@@ -446,7 +451,8 @@ grpc_slice XdsApi::CreateLrsInitialRequest(
   PopulateNode(context, node_, build_version_, user_agent_name_,
                user_agent_version_, node_msg);
   envoy_config_core_v3_Node_add_client_features(
-      node_msg, upb_strview_makez("envoy.lrs.supports_send_all_clusters"),
+      node_msg,
+      upb_StringView_FromString("envoy.lrs.supports_send_all_clusters"),
       arena.ptr());
   MaybeLogLrsRequest(context, request);
   return SerializeLrsRequest(context, request);
@@ -505,9 +511,16 @@ void LocalityStatsPopulate(
 grpc_slice XdsApi::CreateLrsRequest(
     ClusterLoadReportMap cluster_load_report_map) {
   upb::Arena arena;
-  const XdsEncodingContext context = {
-      client_,     tracer_, symtab_->ptr(),
-      arena.ptr(), false,   certificate_provider_definition_map_};
+  // The xDS server info is not actually needed here, so we seed it with an
+  // empty value.
+  XdsBootstrap::XdsServer empty_server;
+  const XdsEncodingContext context = {client_,
+                                      empty_server,
+                                      tracer_,
+                                      symtab_->ptr(),
+                                      arena.ptr(),
+                                      false,
+                                      certificate_provider_definition_map_};
   // Create a request.
   envoy_service_load_stats_v3_LoadStatsRequest* request =
       envoy_service_load_stats_v3_LoadStatsRequest_new(arena.ptr());
@@ -555,8 +568,7 @@ grpc_slice XdsApi::CreateLrsRequest(
     envoy_config_endpoint_v3_ClusterStats_set_total_dropped_requests(
         cluster_stats, total_dropped_requests);
     // Set real load report interval.
-    gpr_timespec timespec =
-        grpc_millis_to_timespec(load_report.load_report_interval, GPR_TIMESPAN);
+    gpr_timespec timespec = load_report.load_report_interval.as_timespec();
     google_protobuf_Duration* load_report_interval =
         envoy_config_endpoint_v3_ClusterStats_mutable_load_report_interval(
             cluster_stats, arena.ptr());
@@ -567,10 +579,10 @@ grpc_slice XdsApi::CreateLrsRequest(
   return SerializeLrsRequest(context, request);
 }
 
-grpc_error_handle XdsApi::ParseLrsResponse(
-    const grpc_slice& encoded_response, bool* send_all_clusters,
-    std::set<std::string>* cluster_names,
-    grpc_millis* load_reporting_interval) {
+grpc_error_handle XdsApi::ParseLrsResponse(const grpc_slice& encoded_response,
+                                           bool* send_all_clusters,
+                                           std::set<std::string>* cluster_names,
+                                           Duration* load_reporting_interval) {
   upb::Arena arena;
   // Decode the response.
   const envoy_service_load_stats_v3_LoadStatsResponse* decoded_response =
@@ -588,7 +600,7 @@ grpc_error_handle XdsApi::ParseLrsResponse(
   } else {
     // Store the cluster names.
     size_t size;
-    const upb_strview* clusters =
+    const upb_StringView* clusters =
         envoy_service_load_stats_v3_LoadStatsResponse_clusters(decoded_response,
                                                                &size);
     for (size_t i = 0; i < size; ++i) {
@@ -599,21 +611,19 @@ grpc_error_handle XdsApi::ParseLrsResponse(
   const google_protobuf_Duration* load_reporting_interval_duration =
       envoy_service_load_stats_v3_LoadStatsResponse_load_reporting_interval(
           decoded_response);
-  gpr_timespec timespec{
+  *load_reporting_interval = Duration::FromSecondsAndNanoseconds(
       google_protobuf_Duration_seconds(load_reporting_interval_duration),
-      google_protobuf_Duration_nanos(load_reporting_interval_duration),
-      GPR_TIMESPAN};
-  *load_reporting_interval = gpr_time_to_millis(timespec);
+      google_protobuf_Duration_nanos(load_reporting_interval_duration));
   return GRPC_ERROR_NONE;
 }
 
 namespace {
 
-google_protobuf_Timestamp* GrpcMillisToTimestamp(
-    const XdsEncodingContext& context, grpc_millis value) {
+google_protobuf_Timestamp* EncodeTimestamp(const XdsEncodingContext& context,
+                                           Timestamp value) {
   google_protobuf_Timestamp* timestamp =
       google_protobuf_Timestamp_new(context.arena);
-  gpr_timespec timespec = grpc_millis_to_timespec(value, GPR_CLOCK_REALTIME);
+  gpr_timespec timespec = value.as_timespec(GPR_CLOCK_REALTIME);
   google_protobuf_Timestamp_set_seconds(timestamp, timespec.tv_sec);
   google_protobuf_Timestamp_set_nanos(timestamp, timespec.tv_nsec);
   return timestamp;
@@ -629,9 +639,16 @@ std::string XdsApi::AssembleClientConfig(
   // Fill-in the node information
   auto* node = envoy_service_status_v3_ClientConfig_mutable_node(client_config,
                                                                  arena.ptr());
-  const XdsEncodingContext context = {
-      client_,     tracer_, symtab_->ptr(),
-      arena.ptr(), true,    certificate_provider_definition_map_};
+  // The xDS server info is not actually needed here, so we seed it with an
+  // empty value.
+  XdsBootstrap::XdsServer empty_server;
+  const XdsEncodingContext context = {client_,
+                                      empty_server,
+                                      tracer_,
+                                      symtab_->ptr(),
+                                      arena.ptr(),
+                                      true,
+                                      certificate_provider_definition_map_};
   PopulateNode(context, node_, build_version_, user_agent_name_,
                user_agent_version_, node);
   // Dump each resource.
@@ -657,7 +674,7 @@ std::string XdsApi::AssembleClientConfig(
         envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_version_info(
             entry, StdStringToUpbString(metadata.version));
         envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_last_updated(
-            entry, GrpcMillisToTimestamp(context, metadata.update_time));
+            entry, EncodeTimestamp(context, metadata.update_time));
         auto* any_field =
             envoy_service_status_v3_ClientConfig_GenericXdsConfig_mutable_xds_config(
                 entry, context.arena);
@@ -677,7 +694,7 @@ std::string XdsApi::AssembleClientConfig(
             StdStringToUpbString(metadata.failed_version));
         envoy_admin_v3_UpdateFailureState_set_last_update_attempt(
             update_failure_state,
-            GrpcMillisToTimestamp(context, metadata.failed_update_time));
+            EncodeTimestamp(context, metadata.failed_update_time));
         envoy_service_status_v3_ClientConfig_GenericXdsConfig_set_error_state(
             entry, update_failure_state);
       }

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

@@ -75,7 +75,7 @@ class XdsApi {
     std::map<RefCountedPtr<XdsLocalityName>, XdsClusterLocalityStats::Snapshot,
              XdsLocalityName::Less>
         locality_stats;
-    grpc_millis load_report_interval;
+    Duration load_report_interval;
   };
   using ClusterLoadReportMap = std::map<
       std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
@@ -106,7 +106,7 @@ class XdsApi {
     // The serialized bytes of the last successfully updated raw xDS resource.
     std::string serialized_proto;
     // The timestamp when the resource was last successfully updated.
-    grpc_millis update_time = 0;
+    Timestamp update_time;
     // The last successfully updated version of the resource.
     std::string version;
     // The rejected version string of the last failed update attempt.
@@ -114,7 +114,7 @@ class XdsApi {
     // Details about the last failed update attempt.
     std::string failed_details;
     // Timestamp of the last failed update attempt.
-    grpc_millis failed_update_time = 0;
+    Timestamp failed_update_time;
   };
   using ResourceMetadataMap =
       std::map<std::string /*resource_name*/, const ResourceMetadata*>;
@@ -168,7 +168,7 @@ class XdsApi {
   grpc_error_handle ParseLrsResponse(const grpc_slice& encoded_response,
                                      bool* send_all_clusters,
                                      std::set<std::string>* cluster_names,
-                                     grpc_millis* load_reporting_interval);
+                                     Duration* load_reporting_interval);
 
   // Assemble the client config proto message and return the serialized result.
   std::string AssembleClientConfig(

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

@@ -32,11 +32,12 @@
 
 #include "src/core/ext/xds/certificate_provider_registry.h"
 #include "src/core/ext/xds/xds_api.h"
-#include "src/core/ext/xds/xds_channel_creds.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/json/json_util.h"
+#include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/fake/fake_credentials.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -65,10 +66,11 @@ grpc_error_handle ParseChannelCreds(const Json::Object& json, size_t idx,
                        /*required=*/false);
   // Select the first channel creds type that we support.
   if (server->channel_creds_type.empty() &&
-      XdsChannelCredsRegistry::IsSupported(type)) {
+      CoreConfiguration::Get().channel_creds_registry().IsSupported(type)) {
     Json config;
     if (config_ptr != nullptr) config = *config_ptr;
-    if (!XdsChannelCredsRegistry::IsValidConfig(type, config)) {
+    if (!CoreConfiguration::Get().channel_creds_registry().IsValidConfig(
+            type, config)) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
           "invalid config for channel creds type \"", type, "\"")));
     }
@@ -137,6 +139,25 @@ XdsBootstrap::XdsServer XdsBootstrap::XdsServer::Parse(
   return server;
 }
 
+Json::Object XdsBootstrap::XdsServer::ToJson() const {
+  Json::Object channel_creds_json{{"type", channel_creds_type}};
+  if (channel_creds_config.type() != Json::Type::JSON_NULL) {
+    channel_creds_json["config"] = channel_creds_config;
+  }
+  Json::Object json{
+      {"server_uri", server_uri},
+      {"channel_creds", Json::Array{std::move(channel_creds_json)}},
+  };
+  if (!server_features.empty()) {
+    Json::Array server_features_json;
+    for (auto& feature : server_features) {
+      server_features_json.emplace_back(feature);
+    }
+    json["server_features"] = std::move(server_features_json);
+  }
+  return json;
+}
+
 bool XdsBootstrap::XdsServer::ShouldUseV3() const {
   return server_features.find("xds_v3") != server_features.end();
 }
@@ -244,6 +265,17 @@ const XdsBootstrap::Authority* XdsBootstrap::LookupAuthority(
   return nullptr;
 }
 
+bool XdsBootstrap::XdsServerExists(
+    const XdsBootstrap::XdsServer& server) const {
+  if (server == servers_[0]) return true;
+  for (auto& authority : authorities_) {
+    for (auto& xds_server : authority.second.xds_servers) {
+      if (server == xds_server) return true;
+    }
+  }
+  return false;
+}
+
 grpc_error_handle XdsBootstrap::ParseXdsServerList(
     Json* json, absl::InlinedVector<XdsServer, 1>* servers) {
   std::vector<grpc_error_handle> error_list;

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

@@ -58,6 +58,13 @@ class XdsBootstrap {
 
     static XdsServer Parse(const Json& json, grpc_error_handle* error);
 
+    bool operator==(const XdsServer& other) const {
+      return (server_uri == other.server_uri &&
+              channel_creds_type == other.channel_creds_type &&
+              channel_creds_config == other.channel_creds_config &&
+              server_features == other.server_features);
+    }
+
     bool operator<(const XdsServer& other) const {
       if (server_uri < other.server_uri) return true;
       if (channel_creds_type < other.channel_creds_type) return true;
@@ -68,6 +75,8 @@ class XdsBootstrap {
       return false;
     }
 
+    Json::Object ToJson() const;
+
     bool ShouldUseV3() const;
   };
 
@@ -105,6 +114,8 @@ class XdsBootstrap {
       const {
     return certificate_providers_;
   }
+  // A util method to check that an xds server exists in this bootstrap file.
+  bool XdsServerExists(const XdsServer& server) const;
 
  private:
   grpc_error_handle ParseXdsServerList(