grpc 1.46.2-x86_64-linux → 1.48.0.pre1-x86_64-linux

data/src/core/lib/gprpp/unique_type_name.h

@@ -0,0 +1,104 @@
+//
+// Copyright 2022 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_CORE_LIB_GPRPP_UNIQUE_TYPE_NAME_H
+#define GRPC_CORE_LIB_GPRPP_UNIQUE_TYPE_NAME_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/gpr/useful.h"
+
+// Provides a type name that is unique by instance rather than by
+// string content.  This is useful in cases where there are different
+// implementations of a given interface that need to be differentiated from
+// each other for down-casting purposes, where it is undesirable to provide
+// a registry to avoid name collisions.
+//
+// Expected usage:
+/*
+// Interface has a virtual method that returns a UniqueTypeName.
+class Interface {
+ public:
+  virtual ~Interface() = default;
+  virtual UniqueTypeName type() const = 0;
+};
+
+// Implementation uses a static factory instance to return the same
+// UniqueTypeName for every instance.
+class FooImplementation : public Interface {
+ public:
+  UniqueTypeName type() const override {
+    static UniqueTypeName::Factory kFactory("Foo");
+    return kFactory.Create();
+  }
+};
+*/
+
+namespace grpc_core {
+
+class UniqueTypeName {
+ public:
+  // Factory class.  There should be a single static instance of this
+  // for each unique type name.
+  class Factory {
+   public:
+    explicit Factory(absl::string_view name) : name_(new std::string(name)) {}
+
+    Factory(const Factory&) = delete;
+    Factory& operator=(const Factory&) = delete;
+
+    UniqueTypeName Create() { return UniqueTypeName(*name_); }
+
+   private:
+    std::string* name_;
+  };
+
+  // Copyable.
+  UniqueTypeName(const UniqueTypeName& other) : name_(other.name_) {}
+  UniqueTypeName& operator=(const UniqueTypeName& other) {
+    name_ = other.name_;
+    return *this;
+  }
+
+  bool operator==(const UniqueTypeName& other) const {
+    return name_.data() == other.name_.data();
+  }
+  bool operator!=(const UniqueTypeName& other) const {
+    return name_.data() != other.name_.data();
+  }
+  bool operator<(const UniqueTypeName& other) const {
+    return name_.data() < other.name_.data();
+  }
+
+  int Compare(const UniqueTypeName& other) const {
+    return QsortCompare(name_.data(), other.name_.data());
+  }
+
+  absl::string_view name() const { return name_; }
+
+ private:
+  explicit UniqueTypeName(absl::string_view name) : name_(name) {}
+
+  absl::string_view name_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_UNIQUE_TYPE_NAME_H

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

@@ -20,20 +20,21 @@
 
 #include "src/core/lib/http/format_request.h"
 
-#include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <algorithm>
+#include <string>
 #include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/http/httpcli.h"
 
 static void fill_common_header(const grpc_http_request* request,
                                const char* host, const char* path,
@@ -95,6 +96,35 @@ grpc_slice grpc_httpcli_format_post_request(const grpc_http_request* request,
   return grpc_slice_from_copied_buffer(req.data(), req.size());
 }
 
+grpc_slice grpc_httpcli_format_put_request(const grpc_http_request* request,
+                                           const char* host, const char* path) {
+  std::vector<std::string> out;
+  out.push_back("PUT ");
+  fill_common_header(request, host, path, true, &out);
+  if (request->body != nullptr) {
+    bool has_content_type = false;
+    for (size_t i = 0; i < request->hdr_count; i++) {
+      if (strcmp(request->hdrs[i].key, "Content-Type") == 0) {
+        has_content_type = true;
+        break;
+      }
+    }
+    if (!has_content_type) {
+      out.push_back("Content-Type: text/plain\r\n");
+    }
+    out.push_back(
+        absl::StrFormat("Content-Length: %lu\r\n",
+                        static_cast<unsigned long>(request->body_length)));
+  }
+  out.push_back("\r\n");
+  std::string req = absl::StrJoin(out, "");
+  if (request->body != nullptr) {
+    absl::StrAppend(&req,
+                    absl::string_view(request->body, request->body_length));
+  }
+  return grpc_slice_from_copied_buffer(req.data(), req.size());
+}
+
 grpc_slice grpc_httpcli_format_connect_request(const grpc_http_request* request,
                                                const char* host,
                                                const char* path) {

data/src/core/lib/http/format_request.h

@@ -23,12 +23,14 @@
 
 #include <grpc/slice.h>
 
-#include "src/core/lib/http/httpcli.h"
+#include "src/core/lib/http/parser.h"
 
 grpc_slice grpc_httpcli_format_get_request(const grpc_http_request* request,
                                            const char* host, const char* path);
 grpc_slice grpc_httpcli_format_post_request(const grpc_http_request* request,
                                             const char* host, const char* path);
+grpc_slice grpc_httpcli_format_put_request(const grpc_http_request* request,
+                                           const char* host, const char* path);
 grpc_slice grpc_httpcli_format_connect_request(const grpc_http_request* request,
                                                const char* host,
                                                const char* path);

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

@@ -20,32 +20,40 @@
 
 #include "src/core/lib/http/httpcli.h"
 
-#include <string.h>
+#include <limits.h>
 
 #include <string>
+#include <utility>
 
+#include "absl/container/inlined_vector.h"
 #include "absl/functional/bind_front.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/slice_buffer.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/channel/channel_args_preconditioning.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/http/format_request.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
+#include "src/core/lib/iomgr/pollset_set.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/security/credentials/credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
 
 namespace grpc_core {
 
@@ -53,6 +61,7 @@ namespace {
 
 grpc_httpcli_get_override g_get_override;
 grpc_httpcli_post_override g_post_override;
+grpc_httpcli_put_override g_put_override;
 void (*g_test_only_on_handshake_done_intercept)(HttpRequest* req);
 
 }  // namespace
@@ -107,10 +116,36 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
       std::move(channel_creds));
 }
 
+OrphanablePtr<HttpRequest> HttpRequest::Put(
+    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_put_override != nullptr) {
+    test_only_generate_response = [request, uri, deadline, on_done,
+                                   response]() {
+      g_put_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:PUT:%s:%s", uri.authority(), uri.path());
+  const grpc_slice request_text = grpc_httpcli_format_put_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 HttpRequest::SetOverride(grpc_httpcli_get_override get,
-                              grpc_httpcli_post_override post) {
+                              grpc_httpcli_post_override post,
+                              grpc_httpcli_put_override put) {
   g_get_override = get;
   g_post_override = post;
+  g_put_override = put;
 }
 
 void HttpRequest::TestOnlySetOnHandshakeDoneIntercept(
@@ -129,7 +164,8 @@ HttpRequest::HttpRequest(
       deadline_(deadline),
       channel_args_(CoreConfiguration::Get()
                         .channel_args_preconditioning()
-                        .PreconditionChannelArgs(channel_args)),
+                        .PreconditionChannelArgs(channel_args)
+                        .ToC()),
       channel_creds_(std::move(channel_creds)),
       on_done_(on_done),
       resource_quota_(ResourceQuotaFromChannelArgs(channel_args_)),
@@ -150,10 +186,6 @@ HttpRequest::HttpRequest(
                     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));
 }
 
 HttpRequest::~HttpRequest() {
@@ -177,7 +209,9 @@ void HttpRequest::Start() {
     return;
   }
   Ref().release();  // ref held by pending DNS resolution
-  dns_request_->Start();
+  dns_request_handle_ = GetDNSResolver()->ResolveName(
+      uri_.authority(), uri_.scheme(), pollset_set_,
+      absl::bind_front(&HttpRequest::OnResolved, this));
 }
 
 void HttpRequest::Orphan() {
@@ -185,21 +219,17 @@ 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));
+    // cancel potentially pending DNS resolution.
+    if (dns_request_handle_.has_value() &&
+        GetDNSResolver()->Cancel(dns_request_handle_.value())) {
+      Finish(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "cancelled during DNS resolution"));
+      Unref();
     }
     if (handshake_mgr_ != nullptr) {
+      // Shutdown will cancel any ongoing tcp connect.
       handshake_mgr_->Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "HTTP request cancelled during security handshake"));
+          "HTTP request cancelled during handshake"));
     }
     if (own_endpoint_ && ep_ != nullptr) {
       grpc_endpoint_shutdown(
@@ -210,15 +240,17 @@ void HttpRequest::Orphan() {
 }
 
 void HttpRequest::AppendError(grpc_error_handle error) {
-  if (overall_error_ == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(overall_error_)) {
     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);
+  auto 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));
+      grpc_error_set_str(
+          error, GRPC_ERROR_STR_TARGET_ADDRESS,
+          addr_text.ok() ? addr_text.value() : addr_text.status().ToString()));
 }
 
 void HttpRequest::OnReadInternal(grpc_error_handle error) {
@@ -227,7 +259,7 @@ void HttpRequest::OnReadInternal(grpc_error_handle error) {
       have_read_byte_ = 1;
       grpc_error_handle err =
           grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr);
-      if (err != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(err)) {
         Finish(err);
         return;
       }
@@ -236,7 +268,7 @@ void HttpRequest::OnReadInternal(grpc_error_handle error) {
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "HTTP1 request cancelled during read", &overall_error_, 1));
-  } else if (error == GRPC_ERROR_NONE) {
+  } else if (GRPC_ERROR_IS_NONE(error)) {
     DoRead();
   } else if (!have_read_byte_) {
     NextAddress(GRPC_ERROR_REF(error));
@@ -249,7 +281,7 @@ 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_) {
+  if (GRPC_ERROR_IS_NONE(error) && !req->cancelled_) {
     req->OnWritten();
   } else {
     req->NextAddress(GRPC_ERROR_REF(error));
@@ -260,7 +292,8 @@ 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);
+  grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr,
+                      /*max_frame_size=*/INT_MAX);
 }
 
 void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
@@ -273,9 +306,8 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
   }
   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());
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    req->handshake_mgr_.reset();
     req->NextAddress(GRPC_ERROR_REF(error));
     return;
   }
@@ -284,75 +316,61 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
   grpc_slice_buffer_destroy_internal(args->read_buffer);
   gpr_free(args->read_buffer);
   req->ep_ = args->endpoint;
+  req->handshake_mgr_.reset();
   if (req->cancelled_) {
     req->NextAddress(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "HTTP request cancelled during security handshake"));
+        "HTTP request cancelled during handshake"));
     return;
   }
   req->StartWrite();
 }
 
-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;
-  }
+void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
   // 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);
+      channel_creds_->create_security_connector(
+          nullptr /*call_creds*/, uri_.authority().c_str(), 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));
+    Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "failed to create security connector", &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(
+  absl::StatusOr<std::string> address = grpc_sockaddr_to_uri(addr);
+  if (!address.ok()) {
+    Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "Failed to extract URI from address", &overall_error_, 1));
+    return;
+  }
+  absl::InlinedVector<grpc_arg, 2> args_to_add = {
+      grpc_security_connector_to_arg(sc.get()),
+      grpc_channel_arg_string_create(
+          const_cast<char*>(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS),
+          const_cast<char*>(address.value().c_str())),
+  };
+  const 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);
+                                         : channel_args_,
+      args_to_add.data(), args_to_add.size());
   grpc_channel_args_destroy(new_args_from_connector);
   // Start the handshake
-  req->handshake_mgr_ = MakeRefCounted<HandshakeManager>();
+  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());
+      HANDSHAKER_CLIENT, new_args, pollset_set_, handshake_mgr_.get());
+  Ref().release();  // ref held by pending handshake
+  grpc_endpoint* ep = ep_;
+  ep_ = nullptr;
+  own_endpoint_ = false;
+  handshake_mgr_->DoHandshake(ep, new_args, deadline_,
+                              /*acceptor=*/nullptr, OnHandshakeDone,
+                              /*user_data=*/this);
   sc.reset(DEBUG_LOCATION, "httpcli");
   grpc_channel_args_destroy(new_args);
 }
 
 void HttpRequest::NextAddress(grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     AppendError(error);
   }
   if (cancelled_) {
@@ -366,28 +384,23 @@ void HttpRequest::NextAddress(grpc_error_handle error) {
     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_);
+  DoHandshake(addr);
 }
 
 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;
-  }
+  dns_request_handle_.reset();
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "cancelled during DNS resolution"));
     return;
   }
+  if (!addresses_or.ok()) {
+    Finish(absl_status_to_grpc_error(addresses_or.status()));
+    return;
+  }
   addresses_ = std::move(*addresses_or);
   next_address_ = 0;
   NextAddress(GRPC_ERROR_NONE);