grpc 1.59.5 → 1.60.0.pre1

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -60,7 +60,6 @@
 
 #include <address_sorting/address_sorting.h>
 
-#include "absl/container/flat_hash_set.h"
 #include "absl/strings/str_cat.h"
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
@@ -70,7 +69,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/service_config/service_config_impl.h"
 #include "src/core/lib/transport/error_utils.h"
 
@@ -178,9 +177,9 @@ class AresClientChannelDNSResolver : public PollingResolver {
     std::unique_ptr<grpc_ares_request> txt_request_
         ABSL_GUARDED_BY(on_resolved_mu_);
     // Output fields from ares request.
-    std::unique_ptr<ServerAddressList> addresses_
+    std::unique_ptr<EndpointAddressesList> addresses_
         ABSL_GUARDED_BY(on_resolved_mu_);
-    std::unique_ptr<ServerAddressList> balancer_addresses_
+    std::unique_ptr<EndpointAddressesList> balancer_addresses_
         ABSL_GUARDED_BY(on_resolved_mu_);
     char* service_config_json_ ABSL_GUARDED_BY(on_resolved_mu_) = nullptr;
   };
@@ -299,7 +298,7 @@ AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
     if (addresses_ != nullptr) {
       result.addresses = std::move(*addresses_);
     } else {
-      result.addresses = ServerAddressList();
+      result.addresses.emplace();
     }
     if (service_config_json_ != nullptr) {
       auto service_config_string = ChooseServiceConfig(service_config_json_);
@@ -320,8 +319,8 @@ AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
       }
     }
     if (balancer_addresses_ != nullptr) {
-      result.args = SetGrpcLbBalancerAddresses(
-          result.args, ServerAddressList(*balancer_addresses_));
+      result.args =
+          SetGrpcLbBalancerAddresses(result.args, *balancer_addresses_);
     }
   } else {
     GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed: %s", this,
@@ -535,7 +534,7 @@ class AresDNSResolver : public DNSResolver {
         absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_resolve_address_done_;
     // currently resolving addresses
-    std::unique_ptr<ServerAddressList> addresses_;
+    std::unique_ptr<EndpointAddressesList> addresses_;
   };
 
   class AresSRVRequest : public AresRequest {
@@ -583,7 +582,7 @@ class AresDNSResolver : public DNSResolver {
         absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_resolve_address_done_;
     // currently resolving addresses
-    std::unique_ptr<ServerAddressList> balancer_addresses_;
+    std::unique_ptr<EndpointAddressesList> balancer_addresses_;
   };
 
   class AresTXTRequest : public AresRequest {

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -19,7 +19,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
-#include <initializer_list>
 #include <vector>
 
 #include "absl/strings/string_view.h"
@@ -73,8 +72,8 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/timer.h"
 
-using grpc_core::ServerAddress;
-using grpc_core::ServerAddressList;
+using grpc_core::EndpointAddresses;
+using grpc_core::EndpointAddressesList;
 
 grpc_core::TraceFlag grpc_trace_cares_address_sorting(false,
                                                       "cares_address_sorting");
@@ -557,7 +556,7 @@ grpc_error_handle grpc_ares_ev_driver_create_locked(
 }
 
 static void log_address_sorting_list(const grpc_ares_request* r,
-                                     const ServerAddressList& addresses,
+                                     const EndpointAddressesList& addresses,
                                      const char* input_output_str) {
   for (size_t i = 0; i < addresses.size(); i++) {
     auto addr_str = grpc_sockaddr_to_string(&addresses[i].address(), true);
@@ -571,7 +570,7 @@ static void log_address_sorting_list(const grpc_ares_request* r,
 }
 
 void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
-                                             ServerAddressList* addresses) {
+                                             EndpointAddressesList* addresses) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_cares_address_sorting)) {
     log_address_sorting_list(r, *addresses, "input");
   }
@@ -584,10 +583,11 @@ void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
     sortables[i].dest_addr.len = (*addresses)[i].address().len;
   }
   address_sorting_rfc_6724_sort(sortables, addresses->size());
-  ServerAddressList sorted;
+  EndpointAddressesList sorted;
   sorted.reserve(addresses->size());
   for (size_t i = 0; i < addresses->size(); ++i) {
-    sorted.emplace_back(*static_cast<ServerAddress*>(sortables[i].user_data));
+    sorted.emplace_back(
+        *static_cast<EndpointAddresses*>(sortables[i].user_data));
   }
   gpr_free(sortables);
   *addresses = std::move(sorted);
@@ -620,7 +620,8 @@ void grpc_ares_complete_request_locked(grpc_ares_request* r)
     // with no addresses along side it
   }
   if (r->balancer_addresses_out != nullptr) {
-    ServerAddressList* balancer_addresses = r->balancer_addresses_out->get();
+    EndpointAddressesList* balancer_addresses =
+        r->balancer_addresses_out->get();
     if (balancer_addresses != nullptr) {
       grpc_cares_wrapper_address_sorting_sort(r, balancer_addresses);
     }
@@ -667,12 +668,12 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
     GRPC_CARES_TRACE_LOG(
         "request:%p on_hostbyname_done_locked qtype=%s host=%s ARES_SUCCESS", r,
         hr->qtype, hr->host);
-    std::unique_ptr<ServerAddressList>* address_list_ptr =
+    std::unique_ptr<EndpointAddressesList>* address_list_ptr =
         hr->is_balancer ? r->balancer_addresses_out : r->addresses_out;
     if (*address_list_ptr == nullptr) {
-      *address_list_ptr = std::make_unique<ServerAddressList>();
+      *address_list_ptr = std::make_unique<EndpointAddressesList>();
     }
-    ServerAddressList& addresses = **address_list_ptr;
+    EndpointAddressesList& addresses = **address_list_ptr;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
       grpc_core::ChannelArgs args;
       if (hr->is_balancer) {
@@ -904,7 +905,7 @@ grpc_error_handle grpc_dns_lookup_ares_continued(
 
 static bool inner_resolve_as_ip_literal_locked(
     const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, std::string* host,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port, std::string* hostport) {
   if (!grpc_core::SplitHostPort(name, host, port)) {
     gpr_log(GPR_ERROR,
@@ -930,7 +931,7 @@ static bool inner_resolve_as_ip_literal_locked(
       grpc_parse_ipv6_hostport(hostport->c_str(), &addr,
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = std::make_unique<ServerAddressList>();
+    *addrs = std::make_unique<EndpointAddressesList>();
     (*addrs)->emplace_back(addr, grpc_core::ChannelArgs());
     return true;
   }
@@ -939,7 +940,7 @@ static bool inner_resolve_as_ip_literal_locked(
 
 static bool resolve_as_ip_literal_locked(
     const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs) {
   std::string host;
   std::string port;
   std::string hostport;
@@ -966,7 +967,7 @@ static bool target_matches_localhost(const char* name) {
 #ifdef GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
 static bool inner_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* r, const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs, std::string* host,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port) {
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
@@ -988,7 +989,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
   }
   if (gpr_stricmp(host->c_str(), "localhost") == 0) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = std::make_unique<grpc_core::ServerAddressList>();
+    *addrs = std::make_unique<grpc_core::EndpointAddressesList>();
     uint16_t numeric_port = grpc_strhtons(port->c_str());
     grpc_resolved_address address;
     // Append the ipv6 loopback address.
@@ -1019,7 +1020,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
 
 static bool grpc_ares_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* r, const char* name, const char* default_port,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs) {
   std::string host;
   std::string port;
   return inner_maybe_resolve_localhost_manually_locked(r, name, default_port,
@@ -1029,7 +1030,7 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 static bool grpc_ares_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* /*r*/, const char* /*name*/,
     const char* /*default_port*/,
-    std::unique_ptr<grpc_core::ServerAddressList>* /*addrs*/) {
+    std::unique_ptr<grpc_core::EndpointAddressesList>* /*addrs*/) {
   return false;
 }
 #endif  // GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
@@ -1037,7 +1038,7 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs,
     int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
@@ -1091,7 +1092,7 @@ static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
 grpc_ares_request* grpc_dns_lookup_srv_ares_impl(
     const char* dns_server, const char* name,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms) {
   grpc_ares_request* r = new grpc_ares_request();
   grpc_core::MutexLock lock(&r->mu);
@@ -1168,13 +1169,13 @@ grpc_ares_request* grpc_dns_lookup_txt_ares_impl(
 grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addrs,
     int query_timeout_ms) = grpc_dns_lookup_hostname_ares_impl;
 
 grpc_ares_request* (*grpc_dns_lookup_srv_ares)(
     const char* dns_server, const char* name,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms) = grpc_dns_lookup_srv_ares_impl;
 
 grpc_ares_request* (*grpc_dns_lookup_txt_ares)(

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -36,7 +36,7 @@
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
@@ -63,10 +63,10 @@ struct grpc_ares_request {
   /// closure to call when the request completes
   grpc_closure* on_done ABSL_GUARDED_BY(mu) = nullptr;
   /// the pointer to receive the resolved addresses
-  std::unique_ptr<grpc_core::ServerAddressList>* addresses_out
+  std::unique_ptr<grpc_core::EndpointAddressesList>* addresses_out
       ABSL_GUARDED_BY(mu);
   /// the pointer to receive the resolved balancer addresses
-  std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses_out
+  std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses_out
       ABSL_GUARDED_BY(mu);
   /// the pointer to receive the service config in JSON
   char** service_config_json_out ABSL_GUARDED_BY(mu) = nullptr;
@@ -92,7 +92,7 @@ struct grpc_ares_request {
 extern grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* addresses,
     int query_timeout_ms);
 
 // Asynchronously resolve a SRV record.
@@ -100,7 +100,7 @@ extern grpc_ares_request* (*grpc_dns_lookup_hostname_ares)(
 extern grpc_ares_request* (*grpc_dns_lookup_srv_ares)(
     const char* dns_server, const char* name,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
+    std::unique_ptr<grpc_core::EndpointAddressesList>* balancer_addresses,
     int query_timeout_ms);
 
 // Asynchronously resolve a TXT record.
@@ -128,7 +128,8 @@ bool grpc_ares_query_ipv6();
 
 // Sorts destinations in lb_addrs according to RFC 6724.
 void grpc_cares_wrapper_address_sorting_sort(
-    const grpc_ares_request* request, grpc_core::ServerAddressList* addresses);
+    const grpc_ares_request* request,
+    grpc_core::EndpointAddressesList* addresses);
 
 // Exposed in this header for C-core tests only
 extern void (*grpc_ares_test_only_inject_config)(ares_channel* channel);

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper_windows.cc

@@ -28,7 +28,7 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/socket_windows.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 

data/src/core/ext/filters/client_channel/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -52,9 +52,9 @@
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_impl.h"
 
@@ -149,8 +149,8 @@ class EventEngineClientChannelDNSResolver : public PollingResolver {
     bool is_srv_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
     bool is_txt_inflight_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
     // Output fields from requests.
-    ServerAddressList addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
-    ServerAddressList balancer_addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
+    EndpointAddressesList addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
+    EndpointAddressesList balancer_addresses_ ABSL_GUARDED_BY(on_resolved_mu_);
     ValidationErrors errors_ ABSL_GUARDED_BY(on_resolved_mu_);
     absl::StatusOr<std::string> service_config_json_
         ABSL_GUARDED_BY(on_resolved_mu_);

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -18,7 +18,6 @@
 
 #include <algorithm>
 #include <memory>
-#include <string>
 #include <utility>
 #include <vector>
 
@@ -44,9 +43,9 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -127,7 +126,7 @@ void NativeClientChannelDNSResolver::OnResolved(
   // Convert result from iomgr DNS API into Resolver::Result.
   Result result;
   if (addresses_or.ok()) {
-    ServerAddressList addresses;
+    EndpointAddressesList addresses;
     for (auto& addr : *addresses_or) {
       addresses.emplace_back(addr, ChannelArgs());
     }