grpc 1.65.2 → 1.66.0.pre3

data/src/core/handshaker/http_connect/http_connect_handshaker.cc

@@ -23,8 +23,10 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -33,7 +35,6 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/handshaker/handshaker.h"
@@ -50,6 +51,8 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/http_client/format_request.h"
 #include "src/core/util/http_client/parser.h"
 #include "src/core/util/string.h"
@@ -61,165 +64,148 @@ namespace {
 class HttpConnectHandshaker : public Handshaker {
  public:
   HttpConnectHandshaker();
-  void Shutdown(grpc_error_handle why) override;
-  void DoHandshake(grpc_tcp_server_acceptor* acceptor,
-                   grpc_closure* on_handshake_done,
-                   HandshakerArgs* args) override;
-  const char* name() const override { return "http_connect"; }
+  absl::string_view name() const override { return "http_connect"; }
+  void DoHandshake(
+      HandshakerArgs* args,
+      absl::AnyInvocable<void(absl::Status)> on_handshake_done) override;
+  void Shutdown(absl::Status error) override;
 
  private:
   ~HttpConnectHandshaker() override;
-  void CleanupArgsForFailureLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  void HandshakeFailedLocked(grpc_error_handle error)
+  void HandshakeFailedLocked(absl::Status error)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnWriteDone(void* arg, grpc_error_handle error);
-  static void OnReadDone(void* arg, grpc_error_handle error);
+  void FinishLocked(absl::Status error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void OnWriteDone(absl::Status error);
+  void OnReadDone(absl::Status error);
+  bool OnReadDoneLocked(absl::Status error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   static void OnWriteDoneScheduler(void* arg, grpc_error_handle error);
   static void OnReadDoneScheduler(void* arg, grpc_error_handle error);
 
   Mutex mu_;
 
-  bool is_shutdown_ ABSL_GUARDED_BY(mu_) = false;
-  // Read buffer to destroy after a shutdown.
-  grpc_slice_buffer* read_buffer_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
-
   // State saved while performing the handshake.
   HandshakerArgs* args_ = nullptr;
-  grpc_closure* on_handshake_done_ = nullptr;
+  absl::AnyInvocable<void(absl::Status)> on_handshake_done_
+      ABSL_GUARDED_BY(mu_);
 
   // Objects for processing the HTTP CONNECT request and response.
-  grpc_slice_buffer write_buffer_ ABSL_GUARDED_BY(mu_);
-  grpc_closure request_done_closure_ ABSL_GUARDED_BY(mu_);
-  grpc_closure response_read_closure_ ABSL_GUARDED_BY(mu_);
+  SliceBuffer write_buffer_ ABSL_GUARDED_BY(mu_);
+  grpc_closure on_write_done_scheduler_ ABSL_GUARDED_BY(mu_);
+  grpc_closure on_read_done_scheduler_ ABSL_GUARDED_BY(mu_);
   grpc_http_parser http_parser_ ABSL_GUARDED_BY(mu_);
   grpc_http_response http_response_ ABSL_GUARDED_BY(mu_);
 };
 
 HttpConnectHandshaker::~HttpConnectHandshaker() {
-  if (read_buffer_to_destroy_ != nullptr) {
-    grpc_slice_buffer_destroy(read_buffer_to_destroy_);
-    gpr_free(read_buffer_to_destroy_);
-  }
-  grpc_slice_buffer_destroy(&write_buffer_);
   grpc_http_parser_destroy(&http_parser_);
   grpc_http_response_destroy(&http_response_);
 }
 
-// Set args fields to nullptr, saving the endpoint and read buffer for
-// later destruction.
-void HttpConnectHandshaker::CleanupArgsForFailureLocked() {
-  read_buffer_to_destroy_ = args_->read_buffer;
-  args_->read_buffer = nullptr;
-  args_->args = ChannelArgs();
-}
-
 // If the handshake failed or we're shutting down, clean up and invoke the
 // callback with the error.
-void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
+void HttpConnectHandshaker::HandshakeFailedLocked(absl::Status error) {
   if (error.ok()) {
     // If we were shut down after an endpoint operation succeeded but
     // before the endpoint callback was invoked, we need to generate our
     // own error.
     error = GRPC_ERROR_CREATE("Handshaker shutdown");
   }
-  if (!is_shutdown_) {
-    // Not shutting down, so the handshake failed.  Clean up before
-    // invoking the callback.
-    grpc_endpoint_destroy(args_->endpoint);
-    args_->endpoint = nullptr;
-    CleanupArgsForFailureLocked();
-    // Set shutdown to true so that subsequent calls to
-    // http_connect_handshaker_shutdown() do nothing.
-    is_shutdown_ = true;
-  }
   // Invoke callback.
-  ExecCtx::Run(DEBUG_LOCATION, on_handshake_done_, error);
+  FinishLocked(std::move(error));
+}
+
+void HttpConnectHandshaker::FinishLocked(absl::Status error) {
+  InvokeOnHandshakeDone(args_, std::move(on_handshake_done_), std::move(error));
 }
 
 // This callback can be invoked inline while already holding onto the mutex. To
 // avoid deadlocks, schedule OnWriteDone on ExecCtx.
+// TODO(roth): This hop will no longer be needed when we migrate to the
+// EventEngine endpoint API.
 void HttpConnectHandshaker::OnWriteDoneScheduler(void* arg,
                                                  grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-  ExecCtx::Run(DEBUG_LOCATION,
-               GRPC_CLOSURE_INIT(&handshaker->request_done_closure_,
-                                 &HttpConnectHandshaker::OnWriteDone,
-                                 handshaker, grpc_schedule_on_exec_ctx),
-               error);
+  handshaker->args_->event_engine->Run(
+      [handshaker, error = std::move(error)]() mutable {
+        ApplicationCallbackExecCtx callback_exec_ctx;
+        ExecCtx exec_ctx;
+        handshaker->OnWriteDone(std::move(error));
+      });
 }
 
 // Callback invoked when finished writing HTTP CONNECT request.
-void HttpConnectHandshaker::OnWriteDone(void* arg, grpc_error_handle error) {
-  auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-  ReleasableMutexLock lock(&handshaker->mu_);
-  if (!error.ok() || handshaker->is_shutdown_) {
+void HttpConnectHandshaker::OnWriteDone(absl::Status error) {
+  ReleasableMutexLock lock(&mu_);
+  if (!error.ok() || args_->endpoint == nullptr) {
     // If the write failed or we're shutting down, clean up and invoke the
     // callback with the error.
-    handshaker->HandshakeFailedLocked(error);
+    HandshakeFailedLocked(error);
     lock.Release();
-    handshaker->Unref();
+    Unref();
   } else {
     // Otherwise, read the response.
     // The read callback inherits our ref to the handshaker.
     grpc_endpoint_read(
-        handshaker->args_->endpoint, handshaker->args_->read_buffer,
-        GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
-                          &HttpConnectHandshaker::OnReadDoneScheduler,
-                          handshaker, grpc_schedule_on_exec_ctx),
+        args_->endpoint.get(), args_->read_buffer.c_slice_buffer(),
+        GRPC_CLOSURE_INIT(&on_read_done_scheduler_,
+                          &HttpConnectHandshaker::OnReadDoneScheduler, this,
+                          grpc_schedule_on_exec_ctx),
         /*urgent=*/true, /*min_progress_size=*/1);
   }
 }
 
 // This callback can be invoked inline while already holding onto the mutex. To
 // avoid deadlocks, schedule OnReadDone on ExecCtx.
+// TODO(roth): This hop will no longer be needed when we migrate to the
+// EventEngine endpoint API.
 void HttpConnectHandshaker::OnReadDoneScheduler(void* arg,
                                                 grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-  ExecCtx::Run(DEBUG_LOCATION,
-               GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
-                                 &HttpConnectHandshaker::OnReadDone, handshaker,
-                                 grpc_schedule_on_exec_ctx),
-               error);
+  handshaker->args_->event_engine->Run(
+      [handshaker, error = std::move(error)]() mutable {
+        ApplicationCallbackExecCtx callback_exec_ctx;
+        ExecCtx exec_ctx;
+        handshaker->OnReadDone(std::move(error));
+      });
 }
 
 // Callback invoked for reading HTTP CONNECT response.
-void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
-  auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
-  ReleasableMutexLock lock(&handshaker->mu_);
-  if (!error.ok() || handshaker->is_shutdown_) {
+void HttpConnectHandshaker::OnReadDone(absl::Status error) {
+  bool done;
+  {
+    MutexLock lock(&mu_);
+    done = OnReadDoneLocked(std::move(error));
+  }
+  if (done) Unref();
+}
+
+bool HttpConnectHandshaker::OnReadDoneLocked(absl::Status error) {
+  if (!error.ok() || args_->endpoint == nullptr) {
     // If the read failed or we're shutting down, clean up and invoke the
     // callback with the error.
-    handshaker->HandshakeFailedLocked(error);
-    goto done;
+    HandshakeFailedLocked(std::move(error));
+    return true;
   }
   // Add buffer to parser.
-  for (size_t i = 0; i < handshaker->args_->read_buffer->count; ++i) {
-    if (GRPC_SLICE_LENGTH(handshaker->args_->read_buffer->slices[i]) > 0) {
+  while (args_->read_buffer.Count() > 0) {
+    Slice slice = args_->read_buffer.TakeFirst();
+    if (!slice.empty()) {
       size_t body_start_offset = 0;
-      error = grpc_http_parser_parse(&handshaker->http_parser_,
-                                     handshaker->args_->read_buffer->slices[i],
+      error = grpc_http_parser_parse(&http_parser_, slice.c_slice(),
                                      &body_start_offset);
       if (!error.ok()) {
-        handshaker->HandshakeFailedLocked(error);
-        goto done;
+        HandshakeFailedLocked(std::move(error));
+        return true;
       }
-      if (handshaker->http_parser_.state == GRPC_HTTP_BODY) {
+      if (http_parser_.state == GRPC_HTTP_BODY) {
         // Remove the data we've already read from the read buffer,
         // leaving only the leftover bytes (if any).
-        grpc_slice_buffer tmp_buffer;
-        grpc_slice_buffer_init(&tmp_buffer);
-        if (body_start_offset <
-            GRPC_SLICE_LENGTH(handshaker->args_->read_buffer->slices[i])) {
-          grpc_slice_buffer_add(
-              &tmp_buffer,
-              grpc_slice_split_tail(&handshaker->args_->read_buffer->slices[i],
-                                    body_start_offset));
+        SliceBuffer tmp_buffer;
+        if (body_start_offset < slice.length()) {
+          tmp_buffer.Append(slice.Split(body_start_offset));
         }
-        grpc_slice_buffer_addn(&tmp_buffer,
-                               &handshaker->args_->read_buffer->slices[i + 1],
-                               handshaker->args_->read_buffer->count - i - 1);
-        grpc_slice_buffer_swap(handshaker->args_->read_buffer, &tmp_buffer);
-        grpc_slice_buffer_destroy(&tmp_buffer);
+        tmp_buffer.TakeAndAppend(args_->read_buffer);
+        tmp_buffer.Swap(&args_->read_buffer);
         break;
       }
     }
@@ -235,65 +221,46 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
   // need to fix the HTTP parser to understand when the body is
   // complete (e.g., handling chunked transfer encoding or looking
   // at the Content-Length: header).
-  if (handshaker->http_parser_.state != GRPC_HTTP_BODY) {
-    grpc_slice_buffer_reset_and_unref(handshaker->args_->read_buffer);
+  if (http_parser_.state != GRPC_HTTP_BODY) {
+    args_->read_buffer.Clear();
     grpc_endpoint_read(
-        handshaker->args_->endpoint, handshaker->args_->read_buffer,
-        GRPC_CLOSURE_INIT(&handshaker->response_read_closure_,
-                          &HttpConnectHandshaker::OnReadDoneScheduler,
-                          handshaker, grpc_schedule_on_exec_ctx),
+        args_->endpoint.get(), args_->read_buffer.c_slice_buffer(),
+        GRPC_CLOSURE_INIT(&on_read_done_scheduler_,
+                          &HttpConnectHandshaker::OnReadDoneScheduler, this,
+                          grpc_schedule_on_exec_ctx),
         /*urgent=*/true, /*min_progress_size=*/1);
-    return;
+    return false;
   }
   // Make sure we got a 2xx response.
-  if (handshaker->http_response_.status < 200 ||
-      handshaker->http_response_.status >= 300) {
+  if (http_response_.status < 200 || http_response_.status >= 300) {
     error = GRPC_ERROR_CREATE(absl::StrCat("HTTP proxy returned response code ",
-                                           handshaker->http_response_.status));
-    handshaker->HandshakeFailedLocked(error);
-    goto done;
+                                           http_response_.status));
+    HandshakeFailedLocked(std::move(error));
+    return true;
   }
   // Success.  Invoke handshake-done callback.
-  ExecCtx::Run(DEBUG_LOCATION, handshaker->on_handshake_done_, error);
-done:
-  // Set shutdown to true so that subsequent calls to
-  // http_connect_handshaker_shutdown() do nothing.
-  handshaker->is_shutdown_ = true;
-  lock.Release();
-  handshaker->Unref();
+  FinishLocked(absl::OkStatus());
+  return true;
 }
 
 //
 // Public handshaker methods
 //
 
-void HttpConnectHandshaker::Shutdown(grpc_error_handle /*why*/) {
-  {
-    MutexLock lock(&mu_);
-    if (!is_shutdown_) {
-      is_shutdown_ = true;
-      grpc_endpoint_destroy(args_->endpoint);
-      args_->endpoint = nullptr;
-      CleanupArgsForFailureLocked();
-    }
-  }
+void HttpConnectHandshaker::Shutdown(absl::Status /*error*/) {
+  MutexLock lock(&mu_);
+  if (on_handshake_done_ != nullptr) args_->endpoint.reset();
 }
 
-void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
-                                        grpc_closure* on_handshake_done,
-                                        HandshakerArgs* args) {
+void HttpConnectHandshaker::DoHandshake(
+    HandshakerArgs* args,
+    absl::AnyInvocable<void(absl::Status)> on_handshake_done) {
   // Check for HTTP CONNECT channel arg.
   // If not found, invoke on_handshake_done without doing anything.
   absl::optional<absl::string_view> server_name =
       args->args.GetString(GRPC_ARG_HTTP_CONNECT_SERVER);
   if (!server_name.has_value()) {
-    // Set shutdown to true so that subsequent calls to
-    // http_connect_handshaker_shutdown() do nothing.
-    {
-      MutexLock lock(&mu_);
-      is_shutdown_ = true;
-    }
-    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, absl::OkStatus());
+    InvokeOnHandshakeDone(args, std::move(on_handshake_done), absl::OkStatus());
     return;
   }
   // Get headers from channel args.
@@ -311,10 +278,9 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
         gpr_malloc(sizeof(grpc_http_header) * num_header_strings));
     for (size_t i = 0; i < num_header_strings; ++i) {
       char* sep = strchr(header_strings[i], ':');
-
       if (sep == nullptr) {
-        gpr_log(GPR_ERROR, "skipping unparseable HTTP CONNECT header: %s",
-                header_strings[i]);
+        LOG(ERROR) << "skipping unparseable HTTP CONNECT header: "
+                   << header_strings[i];
         continue;
       }
       *sep = '\0';
@@ -326,9 +292,9 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   // Save state in the handshaker object.
   MutexLock lock(&mu_);
   args_ = args;
-  on_handshake_done_ = on_handshake_done;
+  on_handshake_done_ = std::move(on_handshake_done);
   // Log connection via proxy.
-  std::string proxy_name(grpc_endpoint_get_peer(args->endpoint));
+  std::string proxy_name(grpc_endpoint_get_peer(args->endpoint.get()));
   std::string server_name_string(*server_name);
   VLOG(2) << "Connecting to server " << server_name_string << " via HTTP proxy "
           << proxy_name;
@@ -342,7 +308,7 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   request.body = nullptr;
   grpc_slice request_slice = grpc_httpcli_format_connect_request(
       &request, server_name_string.c_str(), server_name_string.c_str());
-  grpc_slice_buffer_add(&write_buffer_, request_slice);
+  write_buffer_.Append(Slice(request_slice));
   // Clean up.
   gpr_free(headers);
   for (size_t i = 0; i < num_header_strings; ++i) {
@@ -352,15 +318,14 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   // Take a new ref to be held by the write callback.
   Ref().release();
   grpc_endpoint_write(
-      args->endpoint, &write_buffer_,
-      GRPC_CLOSURE_INIT(&request_done_closure_,
+      args->endpoint.get(), write_buffer_.c_slice_buffer(),
+      GRPC_CLOSURE_INIT(&on_write_done_scheduler_,
                         &HttpConnectHandshaker::OnWriteDoneScheduler, this,
                         grpc_schedule_on_exec_ctx),
       nullptr, /*max_frame_size=*/INT_MAX);
 }
 
 HttpConnectHandshaker::HttpConnectHandshaker() {
-  grpc_slice_buffer_init(&write_buffer_);
   grpc_http_parser_init(&http_parser_, GRPC_HTTP_RESPONSE, &http_response_);
 }
 

data/src/core/handshaker/http_connect/http_proxy_mapper.cc

@@ -41,7 +41,6 @@
 
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/handshaker/http_connect/http_connect_handshaker.h"
@@ -128,13 +127,12 @@ absl::optional<std::string> GetHttpProxyServer(
   if (uri_str->empty()) return absl::nullopt;
   uri = URI::Parse(*uri_str);
   if (!uri.ok() || uri->authority().empty()) {
-    gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var. Error: %s",
-            uri.status().ToString().c_str());
+    LOG(ERROR) << "cannot parse value of 'http_proxy' env var. Error: "
+               << uri.status();
     return absl::nullopt;
   }
   if (uri->scheme() != "http") {
-    gpr_log(GPR_ERROR, "'%s' scheme not supported in proxy URI",
-            uri->scheme().c_str());
+    LOG(ERROR) << "'" << uri->scheme() << "' scheme not supported in proxy URI";
     return absl::nullopt;
   }
   // Split on '@' to separate user credentials from host
@@ -193,9 +191,9 @@ absl::optional<grpc_resolved_address> GetAddressProxyServer(
   }
   auto address = StringToSockaddr(*address_value);
   if (!address.ok()) {
-    gpr_log(GPR_ERROR, "cannot parse value of '%s' env var. Error: %s",
-            HttpProxyMapper::kAddressProxyEnvVar,
-            address.status().ToString().c_str());
+    LOG(ERROR) << "cannot parse value of '"
+               << std::string(HttpProxyMapper::kAddressProxyEnvVar)
+               << "' env var. Error: " << address.status().ToString();
     return absl::nullopt;
   }
   return *address;
@@ -213,10 +211,9 @@ absl::optional<std::string> HttpProxyMapper::MapName(
   if (!name_to_resolve.has_value()) return name_to_resolve;
   absl::StatusOr<URI> uri = URI::Parse(server_uri);
   if (!uri.ok() || uri->path().empty()) {
-    gpr_log(GPR_ERROR,
-            "'http_proxy' environment variable set, but cannot "
-            "parse server URI '%s' -- not using proxy. Error: %s",
-            std::string(server_uri).c_str(), uri.status().ToString().c_str());
+    LOG(ERROR) << "'http_proxy' environment variable set, but cannot "
+                  "parse server URI '"
+               << server_uri << "' -- not using proxy. Error: " << uri.status();
     return absl::nullopt;
   }
   if (uri->scheme() == "unix") {
@@ -272,14 +269,14 @@ absl::optional<grpc_resolved_address> HttpProxyMapper::MapAddress(
   }
   auto address_string = grpc_sockaddr_to_string(&address, true);
   if (!address_string.ok()) {
-    gpr_log(GPR_ERROR, "Unable to convert address to string: %s",
-            std::string(address_string.status().message()).c_str());
+    LOG(ERROR) << "Unable to convert address to string: "
+               << address_string.status();
     return absl::nullopt;
   }
   std::string host_name, port;
   if (!SplitHostPort(*address_string, &host_name, &port)) {
-    gpr_log(GPR_ERROR, "Address %s cannot be split in host and port",
-            address_string->c_str());
+    LOG(ERROR) << "Address " << *address_string
+               << " cannot be split in host and port";
     return absl::nullopt;
   }
   auto enabled_addresses = GetChannelArgOrEnvVarValue(