grpc 1.58.0 → 1.62.0

data/src/core/resolver/google_c2p/google_c2p_resolver.cc

@@ -0,0 +1,326 @@
+//
+// Copyright 2021 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include <cstdint>
+#include <memory>
+#include <random>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/json.h>
+#include <grpc/support/log.h>
+
+#include "src/core/ext/gcp/metadata_query.h"
+#include "src/core/ext/xds/xds_bootstrap.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/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/env.h"
+#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/iomgr/polling_entity.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_writer.h"
+#include "src/core/resolver/resolver.h"
+#include "src/core/resolver/resolver_factory.h"
+#include "src/core/resolver/resolver_registry.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/uri/uri_parser.h"
+
+namespace grpc_core {
+
+namespace {
+
+const char* kC2PAuthority = "traffic-director-c2p.xds.googleapis.com";
+
+class GoogleCloud2ProdResolver : public Resolver {
+ public:
+  explicit GoogleCloud2ProdResolver(ResolverArgs args);
+
+  void StartLocked() override;
+  void RequestReresolutionLocked() override;
+  void ResetBackoffLocked() override;
+  void ShutdownLocked() override;
+
+ private:
+  void ZoneQueryDone(std::string zone);
+  void IPv6QueryDone(bool ipv6_supported);
+  void StartXdsResolver();
+
+  ResourceQuotaRefPtr resource_quota_;
+  std::shared_ptr<WorkSerializer> work_serializer_;
+  grpc_polling_entity pollent_;
+  bool using_dns_ = false;
+  OrphanablePtr<Resolver> child_resolver_;
+  std::string metadata_server_name_ = "metadata.google.internal.";
+  bool shutdown_ = false;
+
+  OrphanablePtr<MetadataQuery> zone_query_;
+  absl::optional<std::string> zone_;
+
+  OrphanablePtr<MetadataQuery> ipv6_query_;
+  absl::optional<bool> supports_ipv6_;
+};
+
+//
+// GoogleCloud2ProdResolver
+//
+
+bool XdsBootstrapConfigured() {
+  return GetEnv("GRPC_XDS_BOOTSTRAP").has_value() ||
+         GetEnv("GRPC_XDS_BOOTSTRAP_CONFIG").has_value();
+}
+
+GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs 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.
+  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();
+  const bool federation_enabled = XdsFederationEnabled();
+  if (!running_on_gcp ||
+      // If the client is already using xDS and federation is not enabled,
+      // we can't use it here, because they may be talking to a completely
+      // different xDS server than we want to.
+      // TODO(roth): When we remove xDS federation env var protection,
+      // remove this constraint.
+      (!federation_enabled && XdsBootstrapConfigured())) {
+    using_dns_ = true;
+    child_resolver_ =
+        CoreConfiguration::Get().resolver_registry().CreateResolver(
+            absl::StrCat("dns:", name_to_resolve), args.args, args.pollset_set,
+            work_serializer_, std::move(args.result_handler));
+    GPR_ASSERT(child_resolver_ != nullptr);
+    return;
+  }
+  // Maybe override metadata server name for testing
+  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.has_value() &&
+      !test_only_metadata_server_override->empty()) {
+    metadata_server_name_ = std::move(*test_only_metadata_server_override);
+  }
+  // Create xds resolver.
+  std::string xds_uri =
+      federation_enabled
+          ? absl::StrCat("xds://", kC2PAuthority, "/", name_to_resolve)
+          : absl::StrCat("xds:", name_to_resolve);
+  child_resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
+      xds_uri, args.args, args.pollset_set, work_serializer_,
+      std::move(args.result_handler));
+  GPR_ASSERT(child_resolver_ != nullptr);
+}
+
+void GoogleCloud2ProdResolver::StartLocked() {
+  if (using_dns_) {
+    child_resolver_->StartLocked();
+    return;
+  }
+  // Using xDS.  Start metadata server queries.
+  zone_query_ = MakeOrphanable<MetadataQuery>(
+      metadata_server_name_, std::string(MetadataQuery::kZoneAttribute),
+      &pollent_,
+      [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
+          std::string /* attribute */,
+          absl::StatusOr<std::string> result) mutable {
+        resolver->work_serializer_->Run(
+            [resolver, result = std::move(result)]() mutable {
+              resolver->ZoneQueryDone(result.ok() ? std::move(result).value()
+                                                  : "");
+            },
+            DEBUG_LOCATION);
+      },
+      Duration::Seconds(10));
+  ipv6_query_ = MakeOrphanable<MetadataQuery>(
+      metadata_server_name_, std::string(MetadataQuery::kIPv6Attribute),
+      &pollent_,
+      [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
+          std::string /* attribute */,
+          absl::StatusOr<std::string> result) mutable {
+        resolver->work_serializer_->Run(
+            [resolver, result = std::move(result)]() {
+              resolver->IPv6QueryDone(result.ok());
+            },
+            DEBUG_LOCATION);
+      },
+      Duration::Seconds(10));
+}
+
+void GoogleCloud2ProdResolver::RequestReresolutionLocked() {
+  if (child_resolver_ != nullptr) {
+    child_resolver_->RequestReresolutionLocked();
+  }
+}
+
+void GoogleCloud2ProdResolver::ResetBackoffLocked() {
+  if (child_resolver_ != nullptr) {
+    child_resolver_->ResetBackoffLocked();
+  }
+}
+
+void GoogleCloud2ProdResolver::ShutdownLocked() {
+  shutdown_ = true;
+  zone_query_.reset();
+  ipv6_query_.reset();
+  child_resolver_.reset();
+}
+
+void GoogleCloud2ProdResolver::ZoneQueryDone(std::string zone) {
+  zone_query_.reset();
+  zone_ = std::move(zone);
+  if (supports_ipv6_.has_value()) StartXdsResolver();
+}
+
+void GoogleCloud2ProdResolver::IPv6QueryDone(bool ipv6_supported) {
+  ipv6_query_.reset();
+  supports_ipv6_ = ipv6_supported;
+  if (zone_.has_value()) StartXdsResolver();
+}
+
+void GoogleCloud2ProdResolver::StartXdsResolver() {
+  if (shutdown_) {
+    return;
+  }
+  // Construct bootstrap JSON.
+  std::random_device rd;
+  std::mt19937 mt(rd());
+  std::uniform_int_distribution<uint64_t> dist(1, UINT64_MAX);
+  Json::Object node = {
+      {"id", Json::FromString(absl::StrCat("C2P-", dist(mt)))},
+  };
+  if (!zone_->empty()) {
+    node["locality"] = Json::FromObject({
+        {"zone", Json::FromString(*zone_)},
+    });
+  };
+  if (*supports_ipv6_) {
+    node["metadata"] = Json::FromObject({
+        {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", Json::FromBool(true)},
+    });
+  }
+  // Allow the TD server uri to be overridden for testing purposes.
+  auto override_server =
+      GetEnv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI");
+  const char* server_uri =
+      override_server.has_value() && !override_server->empty()
+          ? override_server->c_str()
+          : "directpath-pa.googleapis.com";
+  Json xds_server = Json::FromArray({
+      Json::FromObject({
+          {"server_uri", Json::FromString(server_uri)},
+          {"channel_creds",
+           Json::FromArray({
+               Json::FromObject({
+                   {"type", Json::FromString("google_default")},
+               }),
+           })},
+          {"server_features",
+           Json::FromArray({Json::FromString("ignore_resource_deletion")})},
+      }),
+  });
+  Json bootstrap = Json::FromObject({
+      {"xds_servers", xds_server},
+      {"authorities",
+       Json::FromObject({
+           {kC2PAuthority, Json::FromObject({
+                               {"xds_servers", std::move(xds_server)},
+                           })},
+       })},
+      {"node", Json::FromObject(std::move(node))},
+  });
+  // Inject bootstrap JSON as fallback config.
+  internal::SetXdsFallbackBootstrapConfig(JsonDump(bootstrap).c_str());
+  // Now start xDS resolver.
+  child_resolver_->StartLocked();
+}
+
+//
+// Factory
+//
+
+class GoogleCloud2ProdResolverFactory : public ResolverFactory {
+ public:
+  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-experimental 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));
+  }
+};
+
+}  // namespace
+
+void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder) {
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<GoogleCloud2ProdResolverFactory>());
+  builder->resolver_registry()->RegisterResolverFactory(
+      std::make_unique<ExperimentalGoogleCloud2ProdResolverFactory>());
+}
+
+}  // namespace grpc_core

data/src/core/resolver/polling_resolver.cc

@@ -0,0 +1,272 @@
+//
+// Copyright 2015 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/resolver/polling_resolver.h"
+
+#include <inttypes.h>
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/strip.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/backoff/backoff.h"
+#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/resolver/endpoint_addresses.h"
+#include "src/core/service_config/service_config.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+namespace grpc_core {
+
+using ::grpc_event_engine::experimental::EventEngine;
+
+PollingResolver::PollingResolver(ResolverArgs 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_(std::move(args.args)),
+      work_serializer_(std::move(args.work_serializer)),
+      result_handler_(std::move(args.result_handler)),
+      tracer_(tracer),
+      interested_parties_(args.pollset_set),
+      min_time_between_resolutions_(min_time_between_resolutions),
+      backoff_(backoff_options) {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] created", this);
+  }
+}
+
+PollingResolver::~PollingResolver() {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] destroying", this);
+  }
+}
+
+void PollingResolver::StartLocked() { MaybeStartResolvingLocked(); }
+
+void PollingResolver::RequestReresolutionLocked() {
+  if (request_ == nullptr) {
+    // If we're still waiting for a result-health callback from the last
+    // result we reported, don't trigger the re-resolution until we get
+    // that callback.
+    if (result_status_state_ ==
+        ResultStatusState::kResultHealthCallbackPending) {
+      result_status_state_ =
+          ResultStatusState::kReresolutionRequestedWhileCallbackWasPending;
+    } else {
+      MaybeStartResolvingLocked();
+    }
+  }
+}
+
+void PollingResolver::ResetBackoffLocked() {
+  backoff_.Reset();
+  if (next_resolution_timer_handle_.has_value()) {
+    MaybeCancelNextResolutionTimer();
+    StartResolvingLocked();
+  }
+}
+
+void PollingResolver::ShutdownLocked() {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] shutting down", this);
+  }
+  shutdown_ = true;
+  MaybeCancelNextResolutionTimer();
+  request_.reset();
+}
+
+void PollingResolver::ScheduleNextResolutionTimer(const Duration& timeout) {
+  next_resolution_timer_handle_ =
+      channel_args_.GetObject<EventEngine>()->RunAfter(
+          timeout, [self = RefAsSubclass<PollingResolver>()]() mutable {
+            ApplicationCallbackExecCtx callback_exec_ctx;
+            ExecCtx exec_ctx;
+            auto* self_ptr = self.get();
+            self_ptr->work_serializer_->Run(
+                [self = std::move(self)]() { self->OnNextResolutionLocked(); },
+                DEBUG_LOCATION);
+          });
+}
+
+void PollingResolver::OnNextResolutionLocked() {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO,
+            "[polling resolver %p] re-resolution timer fired: shutdown_=%d",
+            this, shutdown_);
+  }
+  // If we haven't been cancelled nor shutdown, then start resolving.
+  if (next_resolution_timer_handle_.has_value() && !shutdown_) {
+    next_resolution_timer_handle_.reset();
+    StartResolvingLocked();
+  }
+}
+
+void PollingResolver::MaybeCancelNextResolutionTimer() {
+  if (next_resolution_timer_handle_.has_value()) {
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      gpr_log(GPR_INFO, "[polling resolver %p] cancel re-resolution timer",
+              this);
+    }
+    channel_args_.GetObject<EventEngine>()->Cancel(
+        *next_resolution_timer_handle_);
+    next_resolution_timer_handle_.reset();
+  }
+}
+
+void PollingResolver::OnRequestComplete(Result result) {
+  Ref(DEBUG_LOCATION, "OnRequestComplete").release();
+  work_serializer_->Run(
+      [this, result]() mutable { OnRequestCompleteLocked(std::move(result)); },
+      DEBUG_LOCATION);
+}
+
+void PollingResolver::OnRequestCompleteLocked(Result result) {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] request complete", this);
+  }
+  request_.reset();
+  if (!shutdown_) {
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      gpr_log(GPR_INFO,
+              "[polling resolver %p] returning result: "
+              "addresses=%s, service_config=%s, resolution_note=%s",
+              this,
+              result.addresses.ok()
+                  ? absl::StrCat("<", result.addresses->size(), " addresses>")
+                        .c_str()
+                  : result.addresses.status().ToString().c_str(),
+              result.service_config.ok()
+                  ? (*result.service_config == nullptr
+                         ? "<null>"
+                         : std::string((*result.service_config)->json_string())
+                               .c_str())
+                  : result.service_config.status().ToString().c_str(),
+              result.resolution_note.c_str());
+    }
+    GPR_ASSERT(result.result_health_callback == nullptr);
+    result.result_health_callback =
+        [self = RefAsSubclass<PollingResolver>(
+             DEBUG_LOCATION, "result_health_callback")](absl::Status status) {
+          self->GetResultStatus(std::move(status));
+        };
+    result_status_state_ = ResultStatusState::kResultHealthCallbackPending;
+    result_handler_->ReportResult(std::move(result));
+  }
+  Unref(DEBUG_LOCATION, "OnRequestComplete");
+}
+
+void PollingResolver::GetResultStatus(absl::Status status) {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] result status from channel: %s",
+            this, status.ToString().c_str());
+  }
+  if (status.ok()) {
+    // Reset backoff state so that we start from the beginning when the
+    // next request gets triggered.
+    backoff_.Reset();
+    // If a re-resolution attempt was requested while the result-status
+    // callback was pending, trigger a new request now.
+    if (std::exchange(result_status_state_, ResultStatusState::kNone) ==
+        ResultStatusState::kReresolutionRequestedWhileCallbackWasPending) {
+      MaybeStartResolvingLocked();
+    }
+  } else {
+    // Set up for retry.
+    // InvalidateNow to avoid getting stuck re-initializing this timer
+    // in a loop while draining the currently-held WorkSerializer.
+    // Also see https://github.com/grpc/grpc/issues/26079.
+    ExecCtx::Get()->InvalidateNow();
+    const Timestamp next_try = backoff_.NextAttemptTime();
+    const Duration timeout = next_try - Timestamp::Now();
+    GPR_ASSERT(!next_resolution_timer_handle_.has_value());
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      if (timeout > Duration::Zero()) {
+        gpr_log(GPR_INFO, "[polling resolver %p] retrying in %" PRId64 " ms",
+                this, timeout.millis());
+      } else {
+        gpr_log(GPR_INFO, "[polling resolver %p] retrying immediately", this);
+      }
+    }
+    ScheduleNextResolutionTimer(timeout);
+    // Reset result_status_state_.  Note that even if re-resolution was
+    // requested while the result-health callback was pending, we can
+    // ignore it here, because we are in backoff to re-resolve anyway.
+    result_status_state_ = ResultStatusState::kNone;
+  }
+}
+
+void PollingResolver::MaybeStartResolvingLocked() {
+  // If there is an existing timer, the time it fires is the earliest time we
+  // can start the next resolution.
+  if (next_resolution_timer_handle_.has_value()) return;
+  if (last_resolution_timestamp_.has_value()) {
+    // InvalidateNow to avoid getting stuck re-initializing this timer
+    // in a loop while draining the currently-held WorkSerializer.
+    // Also see https://github.com/grpc/grpc/issues/26079.
+    ExecCtx::Get()->InvalidateNow();
+    const Timestamp earliest_next_resolution =
+        *last_resolution_timestamp_ + min_time_between_resolutions_;
+    const Duration time_until_next_resolution =
+        earliest_next_resolution - Timestamp::Now();
+    if (time_until_next_resolution > Duration::Zero()) {
+      if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+        const Duration last_resolution_ago =
+            Timestamp::Now() - *last_resolution_timestamp_;
+        gpr_log(GPR_INFO,
+                "[polling resolver %p] in cooldown from last resolution "
+                "(from %" PRId64 " ms ago); will resolve again in %" PRId64
+                " ms",
+                this, last_resolution_ago.millis(),
+                time_until_next_resolution.millis());
+      }
+      ScheduleNextResolutionTimer(time_until_next_resolution);
+      return;
+    }
+  }
+  StartResolvingLocked();
+}
+
+void PollingResolver::StartResolvingLocked() {
+  request_ = StartRequest();
+  last_resolution_timestamp_ = Timestamp::Now();
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    if (request_ != nullptr) {
+      gpr_log(GPR_INFO,
+              "[polling resolver %p] starting resolution, request_=%p", this,
+              request_.get());
+    } else {
+      gpr_log(GPR_INFO, "[polling resolver %p] StartRequest failed", this);
+    }
+  }
+}
+
+}  // namespace grpc_core