grpc 1.42.0 → 1.46.3

data/src/core/lib/http/httpcli.cc

@@ -24,14 +24,17 @@
 
 #include <string>
 
+#include "absl/functional/bind_front.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/http/format_request.h"
@@ -40,285 +43,354 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
+
 namespace {
 
-class InternalRequest {
- public:
-  InternalRequest(const grpc_slice& request_text,
-                  grpc_httpcli_response* response,
-                  grpc_resource_quota* resource_quota, absl::string_view host,
-                  absl::string_view ssl_host_override, grpc_millis deadline,
-                  const grpc_httpcli_handshaker* handshaker,
-                  grpc_closure* on_done, grpc_httpcli_context* context,
-                  grpc_polling_entity* pollent, const char* name)
-      : request_text_(request_text),
-        resource_quota_(resource_quota),
-        host_(host),
-        ssl_host_override_(ssl_host_override),
-        deadline_(deadline),
-        handshaker_(handshaker),
-        on_done_(on_done),
-        context_(context),
-        pollent_(pollent) {
-    grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
-    grpc_slice_buffer_init(&incoming_);
-    grpc_slice_buffer_init(&outgoing_);
-    grpc_iomgr_register_object(&iomgr_obj_, name);
+grpc_httpcli_get_override g_get_override;
+grpc_httpcli_post_override g_post_override;
+void (*g_test_only_on_handshake_done_intercept)(HttpRequest* req);
 
-    GRPC_CLOSURE_INIT(&on_read_, OnRead, this, grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&done_write_, DoneWrite, this, grpc_schedule_on_exec_ctx);
-    GPR_ASSERT(pollent);
-    grpc_polling_entity_add_to_pollset_set(pollent_, context->pollset_set);
-    grpc_resolve_address(
-        host_.c_str(), handshaker_->default_port, context_->pollset_set,
-        GRPC_CLOSURE_CREATE(OnResolved, this, grpc_schedule_on_exec_ctx),
-        &addresses_);
-  }
+}  // namespace
 
-  ~InternalRequest() {
-    grpc_http_parser_destroy(&parser_);
-    if (addresses_ != nullptr) {
-      grpc_resolved_addresses_destroy(addresses_);
-    }
-    if (ep_ != nullptr) {
-      grpc_endpoint_destroy(ep_);
-    }
-    grpc_slice_unref_internal(request_text_);
-    grpc_iomgr_unregister_object(&iomgr_obj_);
-    grpc_slice_buffer_destroy_internal(&incoming_);
-    grpc_slice_buffer_destroy_internal(&outgoing_);
-    GRPC_ERROR_UNREF(overall_error_);
-    grpc_resource_quota_unref_internal(resource_quota_);
+OrphanablePtr<HttpRequest> HttpRequest::Get(
+    URI uri, const grpc_channel_args* channel_args,
+    grpc_polling_entity* pollent, const grpc_http_request* request,
+    Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
+    RefCountedPtr<grpc_channel_credentials> channel_creds) {
+  absl::optional<std::function<void()>> test_only_generate_response;
+  if (g_get_override != nullptr) {
+    test_only_generate_response = [request, uri, deadline, on_done,
+                                   response]() {
+      // Note that capturing request here assumes it will remain alive
+      // until after Start is called. This avoids making a copy as this
+      // code path is only used for test mocks.
+      g_get_override(request, uri.authority().c_str(), uri.path().c_str(),
+                     deadline, on_done, response);
+    };
   }
+  std::string name =
+      absl::StrFormat("HTTP:GET:%s:%s", uri.authority(), uri.path());
+  const grpc_slice request_text = grpc_httpcli_format_get_request(
+      request, uri.authority().c_str(), uri.path().c_str());
+  return MakeOrphanable<HttpRequest>(
+      std::move(uri), request_text, response, deadline, channel_args, on_done,
+      pollent, name.c_str(), std::move(test_only_generate_response),
+      std::move(channel_creds));
+}
 
- private:
-  void Finish(grpc_error_handle error) {
-    grpc_polling_entity_del_from_pollset_set(pollent_, context_->pollset_set);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
-    delete this;
+OrphanablePtr<HttpRequest> HttpRequest::Post(
+    URI uri, const grpc_channel_args* channel_args,
+    grpc_polling_entity* pollent, const grpc_http_request* request,
+    Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
+    RefCountedPtr<grpc_channel_credentials> channel_creds) {
+  absl::optional<std::function<void()>> test_only_generate_response;
+  if (g_post_override != nullptr) {
+    test_only_generate_response = [request, uri, deadline, on_done,
+                                   response]() {
+      g_post_override(request, uri.authority().c_str(), uri.path().c_str(),
+                      request->body, request->body_length, deadline, on_done,
+                      response);
+    };
   }
+  std::string name =
+      absl::StrFormat("HTTP:POST:%s:%s", uri.authority(), uri.path());
+  const grpc_slice request_text = grpc_httpcli_format_post_request(
+      request, uri.authority().c_str(), uri.path().c_str());
+  return MakeOrphanable<HttpRequest>(
+      std::move(uri), request_text, response, deadline, channel_args, on_done,
+      pollent, name.c_str(), std::move(test_only_generate_response),
+      std::move(channel_creds));
+}
 
-  void AppendError(grpc_error_handle error) {
-    if (overall_error_ == GRPC_ERROR_NONE) {
-      overall_error_ =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
-    }
-    grpc_resolved_address* addr = &addresses_->addrs[next_address_ - 1];
-    std::string addr_text = grpc_sockaddr_to_uri(addr);
-    overall_error_ = grpc_error_add_child(
-        overall_error_,
-        grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_text));
-  }
+void HttpRequest::SetOverride(grpc_httpcli_get_override get,
+                              grpc_httpcli_post_override post) {
+  g_get_override = get;
+  g_post_override = post;
+}
 
-  void DoRead() {
-    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true);
-  }
+void HttpRequest::TestOnlySetOnHandshakeDoneIntercept(
+    void (*intercept)(HttpRequest* req)) {
+  g_test_only_on_handshake_done_intercept = intercept;
+}
+
+HttpRequest::HttpRequest(
+    URI uri, const grpc_slice& request_text, grpc_http_response* response,
+    Timestamp deadline, const grpc_channel_args* channel_args,
+    grpc_closure* on_done, grpc_polling_entity* pollent, const char* name,
+    absl::optional<std::function<void()>> test_only_generate_response,
+    RefCountedPtr<grpc_channel_credentials> channel_creds)
+    : uri_(std::move(uri)),
+      request_text_(request_text),
+      deadline_(deadline),
+      channel_args_(CoreConfiguration::Get()
+                        .channel_args_preconditioning()
+                        .PreconditionChannelArgs(channel_args)),
+      channel_creds_(std::move(channel_creds)),
+      on_done_(on_done),
+      resource_quota_(ResourceQuotaFromChannelArgs(channel_args_)),
+      pollent_(pollent),
+      pollset_set_(grpc_pollset_set_create()),
+      test_only_generate_response_(std::move(test_only_generate_response)) {
+  grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
+  grpc_slice_buffer_init(&incoming_);
+  grpc_slice_buffer_init(&outgoing_);
+  grpc_iomgr_register_object(&iomgr_obj_, name);
+  GRPC_CLOSURE_INIT(&on_read_, OnRead, this, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&continue_on_read_after_schedule_on_exec_ctx_,
+                    ContinueOnReadAfterScheduleOnExecCtx, this,
+                    grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&done_write_, DoneWrite, this, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&continue_done_write_after_schedule_on_exec_ctx_,
+                    ContinueDoneWriteAfterScheduleOnExecCtx, this,
+                    grpc_schedule_on_exec_ctx);
+  GPR_ASSERT(pollent);
+  grpc_polling_entity_add_to_pollset_set(pollent, pollset_set_);
+  // Create the DNS resolver. We'll start resolving when Start is called.
+  dns_request_ = GetDNSResolver()->ResolveName(
+      uri_.authority(), uri_.scheme(), pollset_set_,
+      absl::bind_front(&HttpRequest::OnResolved, this));
+}
 
-  static void OnRead(void* user_data, grpc_error_handle error) {
-    InternalRequest* req = static_cast<InternalRequest*>(user_data);
-    req->OnReadInternal(error);
+HttpRequest::~HttpRequest() {
+  grpc_channel_args_destroy(channel_args_);
+  grpc_http_parser_destroy(&parser_);
+  if (own_endpoint_ && ep_ != nullptr) {
+    grpc_endpoint_destroy(ep_);
   }
+  grpc_slice_unref_internal(request_text_);
+  grpc_iomgr_unregister_object(&iomgr_obj_);
+  grpc_slice_buffer_destroy_internal(&incoming_);
+  grpc_slice_buffer_destroy_internal(&outgoing_);
+  GRPC_ERROR_UNREF(overall_error_);
+  grpc_pollset_set_destroy(pollset_set_);
+}
 
-  void OnReadInternal(grpc_error_handle error) {
-    size_t i;
+void HttpRequest::Start() {
+  MutexLock lock(&mu_);
+  if (test_only_generate_response_.has_value()) {
+    test_only_generate_response_.value()();
+    return;
+  }
+  Ref().release();  // ref held by pending DNS resolution
+  dns_request_->Start();
+}
 
-    for (i = 0; i < incoming_.count; i++) {
-      if (GRPC_SLICE_LENGTH(incoming_.slices[i])) {
-        have_read_byte_ = 1;
-        grpc_error_handle err =
-            grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr);
-        if (err != GRPC_ERROR_NONE) {
-          Finish(err);
-          return;
-        }
-      }
+void HttpRequest::Orphan() {
+  {
+    MutexLock lock(&mu_);
+    GPR_ASSERT(!cancelled_);
+    cancelled_ = true;
+    dns_request_.reset();  // cancel potentially pending DNS resolution
+    if (connecting_) {
+      // gRPC's TCP connection establishment API doesn't currently have
+      // a mechanism for cancellation. So invoke the user callback now. The TCP
+      // connection will eventually complete (at least within its deadline), and
+      // we'll simply unref ourselves at that point.
+      // TODO(apolcyn): fix this to cancel the TCP connection attempt when
+      // an API to do so exists.
+      Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+          "HTTP request cancelled during TCP connection establishment",
+          &overall_error_, 1));
     }
-
-    if (error == GRPC_ERROR_NONE) {
-      DoRead();
-    } else if (!have_read_byte_) {
-      NextAddress(GRPC_ERROR_REF(error));
-    } else {
-      Finish(grpc_http_parser_eof(&parser_));
+    if (handshake_mgr_ != nullptr) {
+      handshake_mgr_->Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "HTTP request cancelled during security handshake"));
     }
-  }
-
-  void OnWritten() { DoRead(); }
-
-  static void DoneWrite(void* arg, grpc_error_handle error) {
-    InternalRequest* req = static_cast<InternalRequest*>(arg);
-    if (error == GRPC_ERROR_NONE) {
-      req->OnWritten();
-    } else {
-      req->NextAddress(GRPC_ERROR_REF(error));
+    if (own_endpoint_ && ep_ != nullptr) {
+      grpc_endpoint_shutdown(
+          ep_, GRPC_ERROR_CREATE_FROM_STATIC_STRING("HTTP request cancelled"));
     }
   }
+  Unref();
+}
 
-  void StartWrite() {
-    grpc_slice_ref_internal(request_text_);
-    grpc_slice_buffer_add(&outgoing_, request_text_);
-    grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr);
-  }
-
-  static void OnHandshakeDone(void* arg, grpc_endpoint* ep) {
-    InternalRequest* req = static_cast<InternalRequest*>(arg);
-
-    if (!ep) {
-      req->NextAddress(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Unexplained handshake failure"));
-      return;
-    }
-
-    req->ep_ = ep;
-    req->StartWrite();
+void HttpRequest::AppendError(grpc_error_handle error) {
+  if (overall_error_ == GRPC_ERROR_NONE) {
+    overall_error_ =
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
+  const grpc_resolved_address* addr = &addresses_[next_address_ - 1];
+  std::string addr_text = grpc_sockaddr_to_uri(addr);
+  overall_error_ = grpc_error_add_child(
+      overall_error_,
+      grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_text));
+}
 
-  static void OnConnected(void* arg, grpc_error_handle error) {
-    InternalRequest* req = static_cast<InternalRequest*>(arg);
-
-    if (!req->ep_) {
-      req->NextAddress(GRPC_ERROR_REF(error));
-      return;
+void HttpRequest::OnReadInternal(grpc_error_handle error) {
+  for (size_t i = 0; i < incoming_.count; i++) {
+    if (GRPC_SLICE_LENGTH(incoming_.slices[i])) {
+      have_read_byte_ = 1;
+      grpc_error_handle err =
+          grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr);
+      if (err != GRPC_ERROR_NONE) {
+        Finish(err);
+        return;
+      }
     }
-    req->handshaker_->handshake(req, req->ep_,
-                                req->ssl_host_override_.empty()
-                                    ? req->host_.c_str()
-                                    : req->ssl_host_override_.c_str(),
-                                req->deadline_, OnHandshakeDone);
   }
-
-  void NextAddress(grpc_error_handle error) {
-    grpc_resolved_address* addr;
-    if (error != GRPC_ERROR_NONE) {
-      AppendError(error);
-    }
-    if (next_address_ == addresses_->naddrs) {
-      Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-          "Failed HTTP requests to all targets", &overall_error_, 1));
-      return;
-    }
-    addr = &addresses_->addrs[next_address_++];
-    GRPC_CLOSURE_INIT(&connected_, OnConnected, this,
-                      grpc_schedule_on_exec_ctx);
-    grpc_tcp_client_connect(&connected_, &ep_,
-                            grpc_slice_allocator_create(
-                                resource_quota_, grpc_sockaddr_to_uri(addr)),
-                            context_->pollset_set, nullptr, addr, deadline_);
+  if (cancelled_) {
+    Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "HTTP1 request cancelled during read", &overall_error_, 1));
+  } else if (error == GRPC_ERROR_NONE) {
+    DoRead();
+  } else if (!have_read_byte_) {
+    NextAddress(GRPC_ERROR_REF(error));
+  } else {
+    Finish(grpc_http_parser_eof(&parser_));
   }
+}
 
-  static void OnResolved(void* arg, grpc_error_handle error) {
-    InternalRequest* req = static_cast<InternalRequest*>(arg);
-    if (error != GRPC_ERROR_NONE) {
-      req->Finish(GRPC_ERROR_REF(error));
-      return;
-    }
-    req->next_address_ = 0;
-    req->NextAddress(GRPC_ERROR_NONE);
+void HttpRequest::ContinueDoneWriteAfterScheduleOnExecCtx(
+    void* arg, grpc_error_handle error) {
+  RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(arg));
+  MutexLock lock(&req->mu_);
+  if (error == GRPC_ERROR_NONE && !req->cancelled_) {
+    req->OnWritten();
+  } else {
+    req->NextAddress(GRPC_ERROR_REF(error));
   }
-
-  grpc_slice request_text_;
-  grpc_http_parser parser_;
-  grpc_resolved_addresses* addresses_ = nullptr;
-  size_t next_address_ = 0;
-  grpc_endpoint* ep_ = nullptr;
-  grpc_resource_quota* resource_quota_;
-  std::string host_;
-  std::string ssl_host_override_;
-  grpc_millis deadline_;
-  int have_read_byte_ = 0;
-  const grpc_httpcli_handshaker* handshaker_;
-  grpc_closure* on_done_;
-  grpc_httpcli_context* context_;
-  grpc_polling_entity* pollent_;
-  grpc_iomgr_object iomgr_obj_;
-  grpc_slice_buffer incoming_;
-  grpc_slice_buffer outgoing_;
-  grpc_closure on_read_;
-  grpc_closure done_write_;
-  grpc_closure connected_;
-  grpc_error_handle overall_error_ = GRPC_ERROR_NONE;
-};
-
-}  // namespace
-}  // namespace grpc_core
-
-static grpc_httpcli_get_override g_get_override = nullptr;
-static grpc_httpcli_post_override g_post_override = nullptr;
-
-static void plaintext_handshake(void* arg, grpc_endpoint* endpoint,
-                                const char* /*host*/, grpc_millis /*deadline*/,
-                                void (*on_done)(void* arg,
-                                                grpc_endpoint* endpoint)) {
-  on_done(arg, endpoint);
 }
 
-const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
-                                                        plaintext_handshake};
-
-void grpc_httpcli_context_init(grpc_httpcli_context* context) {
-  context->pollset_set = grpc_pollset_set_create();
+void HttpRequest::StartWrite() {
+  grpc_slice_ref_internal(request_text_);
+  grpc_slice_buffer_add(&outgoing_, request_text_);
+  Ref().release();  // ref held by pending write
+  grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr);
 }
 
-void grpc_httpcli_context_destroy(grpc_httpcli_context* context) {
-  grpc_pollset_set_destroy(context->pollset_set);
+void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
+  auto* args = static_cast<HandshakerArgs*>(arg);
+  RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(args->user_data));
+  if (g_test_only_on_handshake_done_intercept != nullptr) {
+    // Run this testing intercept before the lock so that it has a chance to
+    // do things like calling Orphan on the request
+    g_test_only_on_handshake_done_intercept(req.get());
+  }
+  MutexLock lock(&req->mu_);
+  req->own_endpoint_ = true;
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "Secure transport setup failed: %s",
+            grpc_error_std_string(error).c_str());
+    req->NextAddress(GRPC_ERROR_REF(error));
+    return;
+  }
+  // Handshake completed, so we own fields in args
+  grpc_channel_args_destroy(args->args);
+  grpc_slice_buffer_destroy_internal(args->read_buffer);
+  gpr_free(args->read_buffer);
+  req->ep_ = args->endpoint;
+  if (req->cancelled_) {
+    req->NextAddress(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "HTTP request cancelled during security handshake"));
+    return;
+  }
+  req->StartWrite();
 }
 
-static void internal_request_begin(grpc_httpcli_context* context,
-                                   grpc_polling_entity* pollent,
-                                   grpc_resource_quota* resource_quota,
-                                   const grpc_httpcli_request* request,
-                                   grpc_millis deadline, grpc_closure* on_done,
-                                   grpc_httpcli_response* response,
-                                   const char* name,
-                                   const grpc_slice& request_text) {
-  new grpc_core::InternalRequest(
-      request_text, response, resource_quota, request->host,
-      request->ssl_host_override, deadline,
-      request->handshaker ? request->handshaker : &grpc_httpcli_plaintext,
-      on_done, context, pollent, name);
+void HttpRequest::OnConnected(void* arg, grpc_error_handle error) {
+  RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(arg));
+  MutexLock lock(&req->mu_);
+  req->connecting_ = false;
+  req->own_endpoint_ = true;
+  if (req->cancelled_) {
+    // since we were cancelled while connecting, Finish has already
+    // been called.
+    return;
+  }
+  if (!req->ep_) {
+    req->NextAddress(GRPC_ERROR_REF(error));
+    return;
+  }
+  // TODO(yihuaz): treating nullptr channel_creds_ as insecure is
+  // a hack used to support the port server client (a test utility) in
+  // unsecure builds (when no definition of grpc_insecure_credentials_create
+  // exists). We can remove this hack and unconditionally assume a valid
+  // channel_creds_ object after unsecure builds are deleted, in
+  // https://github.com/grpc/grpc/pull/25586.
+  if (req->channel_creds_ == nullptr) {
+    gpr_log(GPR_DEBUG,
+            "HTTP request skipping handshake because creds are null");
+    req->StartWrite();
+    return;
+  }
+  // Create the security connector using the credentials and target name.
+  grpc_channel_args* new_args_from_connector = nullptr;
+  RefCountedPtr<grpc_channel_security_connector> sc =
+      req->channel_creds_->create_security_connector(
+          nullptr /*call_creds*/, req->uri_.authority().c_str(),
+          req->channel_args_, &new_args_from_connector);
+  if (sc == nullptr) {
+    req->Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "failed to create security connector", &req->overall_error_, 1));
+    return;
+  }
+  grpc_arg security_connector_arg = grpc_security_connector_to_arg(sc.get());
+  grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
+      new_args_from_connector != nullptr ? new_args_from_connector
+                                         : req->channel_args_,
+      &security_connector_arg, 1);
+  grpc_channel_args_destroy(new_args_from_connector);
+  // Start the handshake
+  req->handshake_mgr_ = MakeRefCounted<HandshakeManager>();
+  CoreConfiguration::Get().handshaker_registry().AddHandshakers(
+      HANDSHAKER_CLIENT, new_args, req->pollset_set_,
+      req->handshake_mgr_.get());
+  req->Ref().release();  // ref held by pending handshake
+  grpc_endpoint* ep = req->ep_;
+  req->ep_ = nullptr;
+  req->own_endpoint_ = false;
+  req->handshake_mgr_->DoHandshake(ep, new_args, req->deadline_,
+                                   /*acceptor=*/nullptr, OnHandshakeDone,
+                                   /*user_data=*/req.get());
+  sc.reset(DEBUG_LOCATION, "httpcli");
+  grpc_channel_args_destroy(new_args);
 }
 
-void grpc_httpcli_get(grpc_httpcli_context* context,
-                      grpc_polling_entity* pollent,
-                      grpc_resource_quota* resource_quota,
-                      const grpc_httpcli_request* request, grpc_millis deadline,
-                      grpc_closure* on_done, grpc_httpcli_response* response) {
-  if (g_get_override && g_get_override(request, deadline, on_done, response)) {
-    grpc_resource_quota_unref_internal(resource_quota);
+void HttpRequest::NextAddress(grpc_error_handle error) {
+  if (error != GRPC_ERROR_NONE) {
+    AppendError(error);
+  }
+  if (cancelled_) {
+    Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "HTTP request was cancelled", &overall_error_, 1));
     return;
   }
-  std::string name =
-      absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
-  internal_request_begin(context, pollent, resource_quota, request, deadline,
-                         on_done, response, name.c_str(),
-                         grpc_httpcli_format_get_request(request));
+  if (next_address_ == addresses_.size()) {
+    Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "Failed HTTP requests to all targets", &overall_error_, 1));
+    return;
+  }
+  const grpc_resolved_address* addr = &addresses_[next_address_++];
+  GRPC_CLOSURE_INIT(&connected_, OnConnected, this, grpc_schedule_on_exec_ctx);
+  connecting_ = true;
+  own_endpoint_ = false;
+  Ref().release();  // ref held by pending connect
+  grpc_tcp_client_connect(&connected_, &ep_, pollset_set_, channel_args_, addr,
+                          deadline_);
 }
 
-void grpc_httpcli_post(grpc_httpcli_context* context,
-                       grpc_polling_entity* pollent,
-                       grpc_resource_quota* resource_quota,
-                       const grpc_httpcli_request* request,
-                       const char* body_bytes, size_t body_size,
-                       grpc_millis deadline, grpc_closure* on_done,
-                       grpc_httpcli_response* response) {
-  if (g_post_override && g_post_override(request, body_bytes, body_size,
-                                         deadline, on_done, response)) {
-    grpc_resource_quota_unref_internal(resource_quota);
+void HttpRequest::OnResolved(
+    absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
+  RefCountedPtr<HttpRequest> unreffer(this);
+  MutexLock lock(&mu_);
+  dns_request_.reset();
+  if (!addresses_or.ok()) {
+    Finish(absl_status_to_grpc_error(addresses_or.status()));
     return;
   }
-  std::string name =
-      absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
-  internal_request_begin(
-      context, pollent, resource_quota, request, deadline, on_done, response,
-      name.c_str(),
-      grpc_httpcli_format_post_request(request, body_bytes, body_size));
+  if (cancelled_) {
+    Finish(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "cancelled during DNS resolution"));
+    return;
+  }
+  addresses_ = std::move(*addresses_or);
+  next_address_ = 0;
+  NextAddress(GRPC_ERROR_NONE);
 }
 
-void grpc_httpcli_set_override(grpc_httpcli_get_override get,
-                               grpc_httpcli_post_override post) {
-  g_get_override = get;
-  g_post_override = post;
-}
+}  // namespace grpc_core