grpc 1.53.0.pre2 → 1.54.0

data/src/core/ext/gcp/metadata_query.cc

@@ -0,0 +1,142 @@
+//
+//
+// Copyright 2023 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/ext/gcp/metadata_query.h"
+
+#include <string.h>
+
+#include <initializer_list>
+#include <memory>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+namespace grpc_core {
+
+TraceFlag grpc_metadata_query_trace(false, "metadata_query");
+
+constexpr const char MetadataQuery::kZoneAttribute[] =
+    "/computeMetadata/v1/instance/zone";
+constexpr const char MetadataQuery::kClusterNameAttribute[] =
+    "/computeMetadata/v1/instance/attributes/cluster-name";
+constexpr const char MetadataQuery::kRegionAttribute[] =
+    "/computeMetadata/v1/instance/region";
+constexpr const char MetadataQuery::kInstanceIdAttribute[] =
+    "/computeMetadata/v1/instance/id";
+constexpr const char MetadataQuery::kIPv6Attribute[] =
+    "/computeMetadata/v1/instance/network-interfaces/0/ipv6s";
+
+MetadataQuery::MetadataQuery(
+    std::string attribute, grpc_polling_entity* pollent,
+    absl::AnyInvocable<void(std::string /* attribute */,
+                            absl::StatusOr<std::string> /* result */)>
+        callback,
+    Duration timeout)
+    : MetadataQuery("metadata.google.internal.", std::move(attribute), pollent,
+                    std::move(callback), timeout) {}
+
+MetadataQuery::MetadataQuery(
+    std::string metadata_server_name, std::string attribute,
+    grpc_polling_entity* pollent,
+    absl::AnyInvocable<void(std::string /* attribute */,
+                            absl::StatusOr<std::string> /* result */)>
+        callback,
+    Duration timeout)
+    : InternallyRefCounted<MetadataQuery>(nullptr, 2),
+      attribute_(std::move(attribute)),
+      callback_(std::move(callback)) {
+  GRPC_CLOSURE_INIT(&on_done_, OnDone, this, nullptr);
+  auto uri = URI::Create("http", std::move(metadata_server_name), attribute_,
+                         {} /* query params */, "" /* fragment */);
+  GPR_ASSERT(uri.ok());  // params are hardcoded
+  grpc_http_request request;
+  memset(&request, 0, sizeof(grpc_http_request));
+  grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),
+                             const_cast<char*>("Google")};
+  request.hdr_count = 1;
+  request.hdrs = &header;
+  http_request_ = HttpRequest::Get(
+      std::move(*uri), nullptr /* channel args */, pollent, &request,
+      Timestamp::Now() + timeout, &on_done_, &response_,
+      RefCountedPtr<grpc_channel_credentials>(
+          grpc_insecure_credentials_create()));
+  http_request_->Start();
+}
+
+MetadataQuery::~MetadataQuery() { grpc_http_response_destroy(&response_); }
+
+void MetadataQuery::Orphan() {
+  http_request_.reset();
+  Unref();
+}
+
+void MetadataQuery::OnDone(void* arg, grpc_error_handle error) {
+  auto* self = static_cast<MetadataQuery*>(arg);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
+    gpr_log(GPR_INFO, "MetadataServer Query for %s: HTTP status: %d, error: %s",
+            self->attribute_.c_str(), self->response_.status,
+            StatusToString(error).c_str());
+  }
+  absl::StatusOr<std::string> result;
+  if (!error.ok()) {
+    result = absl::UnavailableError(absl::StrFormat(
+        "MetadataServer Query failed for %s: %s", self->attribute_.c_str(),
+        StatusToString(error).c_str()));
+  } else if (self->response_.status != 200) {
+    result = absl::UnavailableError(absl::StrFormat(
+        "MetadataServer Query received non-200 status for %s: %s",
+        self->attribute_.c_str(), StatusToString(error).c_str()));
+  } else if (self->attribute_ == kZoneAttribute) {
+    absl::string_view body(self->response_.body, self->response_.body_length);
+    size_t pos = body.find_last_of('/');
+    if (pos == body.npos) {
+      result = absl::UnavailableError(
+          absl::StrFormat("MetadataServer Could not parse zone: %s",
+                          std::string(body).c_str()));
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
+        gpr_log(GPR_INFO, "%s", result.status().ToString().c_str());
+      }
+    } else {
+      result = std::string(body.substr(pos + 1));
+    }
+  } else {
+    result = std::string(self->response_.body, self->response_.body_length);
+  }
+  auto callback = std::move(self->callback_);
+  auto attribute = std::move(self->attribute_);
+  self->Unref();
+  return callback(std::move(attribute), std::move(result));
+}
+
+}  // namespace grpc_core

data/src/core/ext/gcp/metadata_query.h

@@ -0,0 +1,82 @@
+//
+// Copyright 2023 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.
+//
+
+#ifndef GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H
+#define GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/time.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/polling_entity.h"
+
+namespace grpc_core {
+
+// Fetches the value of an attribute from the MetadataServer on a GCP
+// environment.
+class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
+ public:
+  static const char kZoneAttribute[];
+  static const char kClusterNameAttribute[];
+  static const char kRegionAttribute[];
+  static const char kInstanceIdAttribute[];
+  static const char kIPv6Attribute[];
+
+  MetadataQuery(
+      std::string attribute, grpc_polling_entity* pollent,
+      absl::AnyInvocable<void(std::string /* attribute */,
+                              absl::StatusOr<std::string> /* result */)>
+          callback,
+      Duration timeout);
+
+  // Alternative ctor allows overriding the metadata server address, mainly
+  // to inject fakes in tests
+  MetadataQuery(
+      std::string metadata_server_name, std::string attribute,
+      grpc_polling_entity* pollent,
+      absl::AnyInvocable<void(std::string /* attribute */,
+                              absl::StatusOr<std::string> /* result */)>
+          callback,
+      Duration timeout);
+
+  ~MetadataQuery() override;
+
+  void Orphan() override;
+
+ private:
+  static void OnDone(void* arg, grpc_error_handle error);
+
+  grpc_closure on_done_;
+  std::string attribute_;
+  absl::AnyInvocable<void(std::string /* attribute */,
+                          absl::StatusOr<std::string> /* result */)>
+      callback_;
+  OrphanablePtr<HttpRequest> http_request_;
+  grpc_http_response response_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -40,6 +40,7 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_posix.h>
 #include <grpc/slice_buffer.h>
@@ -69,7 +70,6 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -94,6 +94,8 @@
 namespace grpc_core {
 namespace {
 
+using ::grpc_event_engine::experimental::EventEngine;
+
 const char kUnixUriPrefix[] = "unix:";
 const char kUnixAbstractUriPrefix[] = "unix-abstract:";
 
@@ -161,7 +163,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       using InternallyRefCounted<HandshakingState>::Ref;
 
      private:
-      static void OnTimeout(void* arg, grpc_error_handle error);
+      void OnTimeout() ABSL_LOCKS_EXCLUDED(&connection_->mu_);
       static void OnReceiveSettings(void* arg, grpc_error_handle /* error */);
       static void OnHandshakeDone(void* arg, grpc_error_handle error);
       RefCountedPtr<ActiveConnection> const connection_;
@@ -171,15 +173,16 @@ class Chttp2ServerListener : public Server::ListenerInterface {
           ABSL_GUARDED_BY(&connection_->mu_);
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
       Timestamp const deadline_;
-      grpc_timer timer_ ABSL_GUARDED_BY(&connection_->mu_);
-      grpc_closure on_timeout_ ABSL_GUARDED_BY(&connection_->mu_);
+      absl::optional<EventEngine::TaskHandle> timer_handle_
+          ABSL_GUARDED_BY(&connection_->mu_);
       grpc_closure on_receive_settings_ ABSL_GUARDED_BY(&connection_->mu_);
       grpc_pollset_set* const interested_parties_;
     };
 
     ActiveConnection(grpc_pollset* accepting_pollset,
                      grpc_tcp_server_acceptor* acceptor,
-                     const ChannelArgs& args, MemoryOwner memory_owner);
+                     EventEngine* event_engine, const ChannelArgs& args,
+                     MemoryOwner memory_owner);
     ~ActiveConnection() override;
 
     void Orphan() override;
@@ -195,7 +198,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
 
    private:
     static void OnClose(void* arg, grpc_error_handle error);
-    static void OnDrainGraceTimeExpiry(void* arg, grpc_error_handle error);
+    void OnDrainGraceTimeExpiry() ABSL_LOCKS_EXCLUDED(&mu_);
 
     RefCountedPtr<Chttp2ServerListener> listener_;
     Mutex mu_ ABSL_ACQUIRED_AFTER(&listener_->mu_);
@@ -206,10 +209,11 @@ class Chttp2ServerListener : public Server::ListenerInterface {
     // is created.
     grpc_chttp2_transport* transport_ ABSL_GUARDED_BY(&mu_) = nullptr;
     grpc_closure on_close_;
-    grpc_timer drain_grace_timer_;
-    grpc_closure on_drain_grace_time_expiry_;
-    bool drain_grace_timer_expiry_callback_pending_ ABSL_GUARDED_BY(&mu_) =
-        false;
+    absl::optional<EventEngine::TaskHandle> drain_grace_timer_handle_
+        ABSL_GUARDED_BY(&mu_);
+    // Use a raw pointer since this event_engine_ is grabbed from the
+    // ChannelArgs of the listener_.
+    EventEngine* const event_engine_ ABSL_GUARDED_BY(&mu_);
     bool shutdown_ ABSL_GUARDED_BY(&mu_) = false;
   };
 
@@ -408,29 +412,33 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::Start(
                              OnHandshakeDone, this);
 }
 
-void Chttp2ServerListener::ActiveConnection::HandshakingState::OnTimeout(
-    void* arg, grpc_error_handle error) {
-  HandshakingState* self = static_cast<HandshakingState*>(arg);
-  // Note that we may be called with absl::OkStatus() when the timer fires
-  // or with an error indicating that the timer system is being shut down.
-  if (error != absl::CancelledError()) {
+void Chttp2ServerListener::ActiveConnection::HandshakingState::OnTimeout() {
+  grpc_chttp2_transport* transport = nullptr;
+  {
+    MutexLock lock(&connection_->mu_);
+    if (timer_handle_.has_value()) {
+      transport = connection_->transport_;
+      timer_handle_.reset();
+    }
+  }
+  if (transport != nullptr) {
     grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->disconnect_with_error = GRPC_ERROR_CREATE(
         "Did not receive HTTP/2 settings before handshake timeout");
-    grpc_chttp2_transport* transport = nullptr;
-    {
-      MutexLock lock(&self->connection_->mu_);
-      transport = self->connection_->transport_;
-    }
     grpc_transport_perform_op(&transport->base, op);
   }
-  self->Unref();
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::
     OnReceiveSettings(void* arg, grpc_error_handle /* error */) {
   HandshakingState* self = static_cast<HandshakingState*>(arg);
-  grpc_timer_cancel(&self->timer_);
+  {
+    MutexLock lock(&self->connection_->mu_);
+    if (self->timer_handle_.has_value()) {
+      self->connection_->event_engine_->Cancel(*self->timer_handle_);
+      self->timer_handle_.reset();
+    }
+  }
   self->Unref();
 }
 
@@ -503,10 +511,15 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           grpc_chttp2_transport_start_reading(transport, args->read_buffer,
                                               &self->on_receive_settings_,
                                               on_close);
-          self->Ref().release();  // Held by OnTimeout().
-          GRPC_CLOSURE_INIT(&self->on_timeout_, OnTimeout, self,
-                            grpc_schedule_on_exec_ctx);
-          grpc_timer_init(&self->timer_, self->deadline_, &self->on_timeout_);
+          self->timer_handle_ = self->connection_->event_engine_->RunAfter(
+              self->deadline_ - Timestamp::Now(),
+              [self = self->Ref()]() mutable {
+                ApplicationCallbackExecCtx callback_exec_ctx;
+                ExecCtx exec_ctx;
+                self->OnTimeout();
+                // HandshakingState deletion might require an active ExecCtx.
+                self.reset();
+              });
         } else {
           // Failed to create channel from transport. Clean up.
           gpr_log(GPR_ERROR, "Failed to create channel: %s",
@@ -548,9 +561,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
 
 Chttp2ServerListener::ActiveConnection::ActiveConnection(
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    const ChannelArgs& args, MemoryOwner memory_owner)
+    EventEngine* event_engine, const ChannelArgs& args,
+    MemoryOwner memory_owner)
     : handshaking_state_(memory_owner.MakeOrphanable<HandshakingState>(
-          Ref(), accepting_pollset, acceptor, args)) {
+          Ref(), accepting_pollset, acceptor, args)),
+      event_engine_(event_engine) {
   GRPC_CLOSURE_INIT(&on_close_, ActiveConnection::OnClose, this,
                     grpc_schedule_on_exec_ctx);
 }
@@ -579,20 +594,18 @@ void Chttp2ServerListener::ActiveConnection::SendGoAway() {
     MutexLock lock(&mu_);
     if (transport_ != nullptr && !shutdown_) {
       transport = transport_;
-      Ref().release();  // Ref held by OnDrainGraceTimeExpiry
-      GRPC_CLOSURE_INIT(&on_drain_grace_time_expiry_, OnDrainGraceTimeExpiry,
-                        this, nullptr);
-      grpc_timer_init(
-          &drain_grace_timer_,
-          Timestamp::Now() +
-              std::max(
-                  Duration::Zero(),
-                  listener_->args_
-                      .GetDurationFromIntMillis(
-                          GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS)
-                      .value_or(Duration::Minutes(10))),
-          &on_drain_grace_time_expiry_);
-      drain_grace_timer_expiry_callback_pending_ = true;
+      drain_grace_timer_handle_ = event_engine_->RunAfter(
+          std::max(Duration::Zero(),
+                   listener_->args_
+                       .GetDurationFromIntMillis(
+                           GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS)
+                       .value_or(Duration::Minutes(10))),
+          [self = Ref(DEBUG_LOCATION, "drain_grace_timer")]() mutable {
+            ApplicationCallbackExecCtx callback_exec_ctx;
+            ExecCtx exec_ctx;
+            self->OnDrainGraceTimeExpiry();
+            self.reset(DEBUG_LOCATION, "drain_grace_timer");
+          });
       shutdown_ = true;
     }
   }
@@ -637,30 +650,31 @@ void Chttp2ServerListener::ActiveConnection::OnClose(
       self->shutdown_ = true;
     }
     // Cancel the drain_grace_timer_ if needed.
-    if (self->drain_grace_timer_expiry_callback_pending_) {
-      grpc_timer_cancel(&self->drain_grace_timer_);
+    if (self->drain_grace_timer_handle_.has_value()) {
+      self->event_engine_->Cancel(*self->drain_grace_timer_handle_);
+      self->drain_grace_timer_handle_.reset();
     }
   }
   self->Unref();
 }
 
-void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry(
-    void* arg, grpc_error_handle error) {
-  ActiveConnection* self = static_cast<ActiveConnection*>(arg);
+void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry() {
+  grpc_chttp2_transport* transport = nullptr;
   // If the drain_grace_timer_ was not cancelled, disconnect the transport
   // immediately.
-  if (error.ok()) {
-    grpc_chttp2_transport* transport = nullptr;
-    {
-      MutexLock lock(&self->mu_);
-      transport = self->transport_;
+  {
+    MutexLock lock(&mu_);
+    if (drain_grace_timer_handle_.has_value()) {
+      transport = transport_;
+      drain_grace_timer_handle_.reset();
     }
+  }
+  if (transport != nullptr) {
     grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->disconnect_with_error = GRPC_ERROR_CREATE(
         "Drain grace time expired. Closing connection immediately.");
     grpc_transport_perform_op(&transport->base, op);
   }
-  self->Unref();
 }
 
 //
@@ -830,8 +844,9 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
   }
   auto memory_owner = self->memory_quota_->CreateMemoryOwner(
       absl::StrCat(grpc_endpoint_get_peer(tcp), ":server_channel"));
+  EventEngine* const event_engine = self->args_.GetObject<EventEngine>();
   auto connection = memory_owner.MakeOrphanable<ActiveConnection>(
-      accepting_pollset, acceptor, args, std::move(memory_owner));
+      accepting_pollset, acceptor, event_engine, args, std::move(memory_owner));
   // We no longer own acceptor
   acceptor = nullptr;
   // Hold a ref to connection to allow starting handshake outside the