grpc 1.48.0-x86_64-linux → 1.49.1-x86_64-linux

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -39,7 +39,7 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/env.h"
@@ -48,18 +48,17 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 #include "src/core/lib/resolver/resolver_registry.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -269,16 +268,17 @@ void GoogleCloud2ProdResolver::IPv6Query::OnDone(
 //
 
 GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
-    : resource_quota_(ResourceQuotaFromChannelArgs(args.args)),
+    : resource_quota_(args.args.GetObjectRef<ResourceQuota>()),
       work_serializer_(std::move(args.work_serializer)),
       pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)) {
   absl::string_view name_to_resolve = absl::StripPrefix(args.uri.path(), "/");
   // If we're not running on GCP, we can't use DirectPath, so delegate
   // to the DNS resolver.
-  bool test_only_pretend_running_on_gcp = grpc_channel_args_find_bool(
-      args.args, "grpc.testing.google_c2p_resolver_pretend_running_on_gcp",
-      false);
-  bool running_on_gcp =
+  const bool test_only_pretend_running_on_gcp =
+      args.args
+          .GetBool("grpc.testing.google_c2p_resolver_pretend_running_on_gcp")
+          .value_or(false);
+  const bool running_on_gcp =
       test_only_pretend_running_on_gcp || grpc_alts_is_running_on_gcp();
   if (!running_on_gcp ||
       // If the client is already using xDS, we can't use it here, because
@@ -296,13 +296,12 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
     return;
   }
   // Maybe override metadata server name for testing
-  const char* test_only_metadata_server_override =
-      grpc_channel_args_find_string(
-          args.args,
+  absl::optional<std::string> test_only_metadata_server_override =
+      args.args.GetOwnedString(
           "grpc.testing.google_c2p_resolver_metadata_server_override");
-  if (test_only_metadata_server_override != nullptr &&
-      strlen(test_only_metadata_server_override) > 0) {
-    metadata_server_name_ = std::string(test_only_metadata_server_override);
+  if (test_only_metadata_server_override.has_value() &&
+      !test_only_metadata_server_override->empty()) {
+    metadata_server_name_ = std::move(*test_only_metadata_server_override);
   }
   // Create xds resolver.
   child_resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
@@ -415,15 +414,35 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
 
 class GoogleCloud2ProdResolverFactory : public ResolverFactory {
  public:
-  // TODO(roth): Remove experimental suffix once this code is proven stable,
-  // and update the scheme in google_c2p_resolver_test.cc when doing so.
+  absl::string_view scheme() const override { return "google-c2p"; }
+
+  bool IsValidUri(const URI& uri) const override {
+    if (GPR_UNLIKELY(!uri.authority().empty())) {
+      gpr_log(GPR_ERROR, "google-c2p URI scheme does not support authorities");
+      return false;
+    }
+    return true;
+  }
+
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    if (!IsValidUri(args.uri)) return nullptr;
+    return MakeOrphanable<GoogleCloud2ProdResolver>(std::move(args));
+  }
+};
+
+// TODO(apolcyn): remove this class after user code has updated to the
+// stable "google-c2p" URI scheme.
+class ExperimentalGoogleCloud2ProdResolverFactory : public ResolverFactory {
+ public:
   absl::string_view scheme() const override {
     return "google-c2p-experimental";
   }
 
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
-      gpr_log(GPR_ERROR, "google-c2p URI scheme does not support authorities");
+      gpr_log(
+          GPR_ERROR,
+          "google-c2p-experimental URI scheme does not support authorities");
       return false;
     }
     return true;
@@ -440,6 +459,8 @@ class GoogleCloud2ProdResolverFactory : public ResolverFactory {
 void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder) {
   builder->resolver_registry()->RegisterResolverFactory(
       absl::make_unique<GoogleCloud2ProdResolverFactory>());
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<ExperimentalGoogleCloud2ProdResolverFactory>());
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/polling_resolver.cc

@@ -33,21 +33,21 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
 PollingResolver::PollingResolver(ResolverArgs args,
-                                 const grpc_channel_args* channel_args,
+                                 const ChannelArgs& channel_args,
                                  Duration min_time_between_resolutions,
                                  BackOff::Options backoff_options,
                                  TraceFlag* tracer)
     : authority_(args.uri.authority()),
       name_to_resolve_(absl::StripPrefix(args.uri.path(), "/")),
-      channel_args_(grpc_channel_args_copy(channel_args)),
+      channel_args_(channel_args),
       work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
       tracer_(tracer),
@@ -63,7 +63,6 @@ PollingResolver::~PollingResolver() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
     gpr_log(GPR_INFO, "[polling resolver %p] destroying", this);
   }
-  grpc_channel_args_destroy(channel_args_);
 }
 
 void PollingResolver::StartLocked() { MaybeStartResolvingLocked(); }

data/src/core/ext/filters/client_channel/resolver/polling_resolver.h

@@ -24,17 +24,16 @@
 
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
 #include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #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/iomgr/timer.h"
-#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
 
@@ -45,7 +44,7 @@ namespace grpc_core {
 // Implementations need only to implement StartRequest().
 class PollingResolver : public Resolver {
  public:
-  PollingResolver(ResolverArgs args, const grpc_channel_args* channel_args,
+  PollingResolver(ResolverArgs args, const ChannelArgs& channel_args,
                   Duration min_time_between_resolutions,
                   BackOff::Options backoff_options, TraceFlag* tracer);
   ~PollingResolver() override;
@@ -70,7 +69,7 @@ class PollingResolver : public Resolver {
   const std::string& authority() const { return authority_; }
   const std::string& name_to_resolve() const { return name_to_resolve_; }
   grpc_pollset_set* interested_parties() const { return interested_parties_; }
-  const grpc_channel_args* channel_args() const { return channel_args_; }
+  const ChannelArgs& channel_args() const { return channel_args_; }
 
  private:
   void MaybeStartResolvingLocked();
@@ -86,7 +85,7 @@ class PollingResolver : public Resolver {
   /// name to resolve
   std::string name_to_resolve_;
   /// channel args
-  const grpc_channel_args* channel_args_ = nullptr;
+  ChannelArgs channel_args_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
   TraceFlag* tracer_;

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -19,7 +19,6 @@
 #include <algorithm>
 #include <memory>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/memory/memory.h"
@@ -27,7 +26,6 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
@@ -49,7 +47,6 @@ namespace {
 class SockaddrResolver : public Resolver {
  public:
   SockaddrResolver(ServerAddressList addresses, ResolverArgs args);
-  ~SockaddrResolver() override;
 
   void StartLocked() override;
 
@@ -58,25 +55,19 @@ class SockaddrResolver : public Resolver {
  private:
   std::unique_ptr<ResultHandler> result_handler_;
   ServerAddressList addresses_;
-  const grpc_channel_args* channel_args_ = nullptr;
+  ChannelArgs channel_args_;
 };
 
 SockaddrResolver::SockaddrResolver(ServerAddressList addresses,
                                    ResolverArgs args)
     : result_handler_(std::move(args.result_handler)),
       addresses_(std::move(addresses)),
-      channel_args_(grpc_channel_args_copy(args.args)) {}
-
-SockaddrResolver::~SockaddrResolver() {
-  grpc_channel_args_destroy(channel_args_);
-}
+      channel_args_(std::move(args.args)) {}
 
 void SockaddrResolver::StartLocked() {
   Result result;
   result.addresses = std::move(addresses_);
-  // TODO(roth): Use std::move() once channel args is converted to C++.
-  result.args = channel_args_;
-  channel_args_ = nullptr;
+  result.args = std::move(channel_args_);
   result_handler_->ReportResult(std::move(result));
 }
 
@@ -106,7 +97,7 @@ bool ParseUri(const URI& uri,
       break;
     }
     if (addresses != nullptr) {
-      addresses->emplace_back(addr, nullptr /* args */);
+      addresses->emplace_back(addr, ChannelArgs());
     }
   }
   return !errors_found;