grpc 1.65.1 → 1.66.0.pre3

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -25,6 +25,7 @@
 #include <stdint.h>
 
 #include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/impl/compression_types.h>
@@ -110,6 +111,8 @@ class ClientCompressionFilter final
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "compression"; }
+
   static absl::StatusOr<std::unique_ptr<ClientCompressionFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
@@ -147,6 +150,8 @@ class ServerCompressionFilter final
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "compression"; }
+
   static absl::StatusOr<std::unique_ptr<ServerCompressionFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -25,12 +25,12 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/log/log.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -55,7 +55,7 @@ const NoInterceptor HttpServerFilter::Call::OnFinalize;
 
 const grpc_channel_filter HttpServerFilter::kFilter =
     MakePromiseBasedFilter<HttpServerFilter, FilterEndpoint::kServer,
-                           kFilterExaminesServerInitialMetadata>("http-server");
+                           kFilterExaminesServerInitialMetadata>();
 
 namespace {
 void FilterOutgoingMetadata(ServerMetadata* md) {
@@ -140,8 +140,8 @@ ServerMetadataHandle HttpServerFilter::Call::OnClientInitialMetadata(
 
 void HttpServerFilter::Call::OnServerInitialMetadata(ServerMetadata& md) {
   if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    gpr_log(GPR_INFO, "%s[http-server] Write metadata",
-            GetContext<Activity>()->DebugTag().c_str());
+    LOG(INFO) << GetContext<Activity>()->DebugTag()
+              << "[http-server] Write metadata";
   }
   FilterOutgoingMetadata(&md);
   md.Set(HttpStatusMetadata(), 200);

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -36,6 +36,8 @@ class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "http-server"; }
+
   static absl::StatusOr<std::unique_ptr<HttpServerFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -23,11 +23,11 @@
 #include <functional>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -137,12 +137,12 @@ size_t MessageSizeParser::ParserIndex() {
 const grpc_channel_filter ClientMessageSizeFilter::kFilter =
     MakePromiseBasedFilter<ClientMessageSizeFilter, FilterEndpoint::kClient,
                            kFilterExaminesOutboundMessages |
-                               kFilterExaminesInboundMessages>("message_size");
+                               kFilterExaminesInboundMessages>();
 
 const grpc_channel_filter ServerMessageSizeFilter::kFilter =
     MakePromiseBasedFilter<ServerMessageSizeFilter, FilterEndpoint::kServer,
                            kFilterExaminesOutboundMessages |
-                               kFilterExaminesInboundMessages>("message_size");
+                               kFilterExaminesInboundMessages>();
 
 absl::StatusOr<std::unique_ptr<ClientMessageSizeFilter>>
 ClientMessageSizeFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
@@ -160,19 +160,17 @@ ServerMetadataHandle CheckPayload(const Message& msg,
                                   bool is_client, bool is_send) {
   if (!max_length.has_value()) return nullptr;
   if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    gpr_log(GPR_INFO, "%s[message_size] %s len:%" PRIdPTR " max:%d",
-            GetContext<Activity>()->DebugTag().c_str(),
-            is_send ? "send" : "recv", msg.payload()->Length(), *max_length);
+    LOG(INFO) << GetContext<Activity>()->DebugTag() << "[message_size] "
+              << (is_send ? "send" : "recv")
+              << " len:" << msg.payload()->Length() << " max:" << *max_length;
   }
   if (msg.payload()->Length() <= *max_length) return nullptr;
-  auto r = Arena::MakePooled<ServerMetadata>();
-  r->Set(GrpcStatusMetadata(), GRPC_STATUS_RESOURCE_EXHAUSTED);
-  r->Set(GrpcMessageMetadata(),
-         Slice::FromCopiedString(absl::StrFormat(
-             "%s: %s message larger than max (%u vs. %d)",
-             is_client ? "CLIENT" : "SERVER", is_send ? "Sent" : "Received",
-             msg.payload()->Length(), *max_length)));
-  return r;
+  return ServerMetadataFromStatus(
+      GRPC_STATUS_RESOURCE_EXHAUSTED,
+      absl::StrFormat("%s: %s message larger than max (%u vs. %d)",
+                      is_client ? "CLIENT" : "SERVER",
+                      is_send ? "Sent" : "Received", msg.payload()->Length(),
+                      *max_length));
 }
 }  // namespace
 

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -89,6 +89,8 @@ class ServerMessageSizeFilter final
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "message_size"; }
+
   static absl::StatusOr<std::unique_ptr<ServerMessageSizeFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
@@ -117,6 +119,8 @@ class ClientMessageSizeFilter final
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "message_size"; }
+
   static absl::StatusOr<std::unique_ptr<ClientMessageSizeFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/filters/rbac/rbac_filter.cc

@@ -71,7 +71,7 @@ absl::Status RbacFilter::Call::OnClientInitialMetadata(ClientMetadata& md,
 }
 
 const grpc_channel_filter RbacFilter::kFilterVtable =
-    MakePromiseBasedFilter<RbacFilter, FilterEndpoint::kServer>("rbac_filter");
+    MakePromiseBasedFilter<RbacFilter, FilterEndpoint::kServer>();
 
 RbacFilter::RbacFilter(size_t index,
                        EvaluateArgs::PerChannelArgs per_channel_evaluate_args)

data/src/core/ext/filters/rbac/rbac_filter.h

@@ -42,6 +42,8 @@ class RbacFilter : public ImplementChannelFilter<RbacFilter> {
   // and enforces the RBAC policy.
   static const grpc_channel_filter kFilterVtable;
 
+  static absl::string_view TypeName() { return "rbac_filter"; }
+
   static absl::StatusOr<std::unique_ptr<RbacFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -69,8 +69,7 @@ UniqueTypeName XdsOverrideHostAttribute::TypeName() {
 
 const grpc_channel_filter StatefulSessionFilter::kFilter =
     MakePromiseBasedFilter<StatefulSessionFilter, FilterEndpoint::kClient,
-                           kFilterExaminesServerInitialMetadata>(
-        "stateful_session_filter");
+                           kFilterExaminesServerInitialMetadata>();
 
 absl::StatusOr<std::unique_ptr<StatefulSessionFilter>>
 StatefulSessionFilter::Create(const ChannelArgs&,

data/src/core/ext/filters/stateful_session/stateful_session_filter.h

@@ -74,6 +74,8 @@ class StatefulSessionFilter
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "stateful_session_filter"; }
+
   static absl::StatusOr<std::unique_ptr<StatefulSessionFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -36,7 +36,6 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
@@ -66,7 +65,6 @@
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/insecure/insecure_credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/surface/channel_stack_type.h"
@@ -120,10 +118,12 @@ void Chttp2Connector::Connect(const Args& args, Result* result,
   CoreConfiguration::Get().handshaker_registry().AddHandshakers(
       HANDSHAKER_CLIENT, channel_args, args_.interested_parties,
       handshake_mgr_.get());
-  Ref().release();  // Ref held by OnHandshakeDone().
-  handshake_mgr_->DoHandshake(nullptr /* endpoint */, channel_args,
-                              args.deadline, nullptr /* acceptor */,
-                              OnHandshakeDone, this);
+  handshake_mgr_->DoHandshake(
+      /*endpoint=*/nullptr, channel_args, args.deadline, /*acceptor=*/nullptr,
+      [self = RefAsSubclass<Chttp2Connector>()](
+          absl::StatusOr<HandshakerArgs*> result) {
+        self->OnHandshakeDone(std::move(result));
+      });
 }
 
 void Chttp2Connector::Shutdown(grpc_error_handle error) {
@@ -135,54 +135,44 @@ void Chttp2Connector::Shutdown(grpc_error_handle error) {
   }
 }
 
-void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
-  auto* args = static_cast<HandshakerArgs*>(arg);
-  Chttp2Connector* self = static_cast<Chttp2Connector*>(args->user_data);
-  {
-    MutexLock lock(&self->mu_);
-    if (!error.ok() || self->shutdown_) {
-      if (error.ok()) {
-        error = GRPC_ERROR_CREATE("connector shutdown");
-        // We were shut down after handshaking completed successfully, so
-        // destroy the endpoint here.
-        if (args->endpoint != nullptr) {
-          grpc_endpoint_destroy(args->endpoint);
-          grpc_slice_buffer_destroy(args->read_buffer);
-          gpr_free(args->read_buffer);
-        }
-      }
-      self->result_->Reset();
-      NullThenSchedClosure(DEBUG_LOCATION, &self->notify_, error);
-    } else if (args->endpoint != nullptr) {
-      self->result_->transport =
-          grpc_create_chttp2_transport(args->args, args->endpoint, true);
-      CHECK_NE(self->result_->transport, nullptr);
-      self->result_->socket_node =
-          grpc_chttp2_transport_get_socket_node(self->result_->transport);
-      self->result_->channel_args = args->args;
-      self->Ref().release();  // Ref held by OnReceiveSettings()
-      GRPC_CLOSURE_INIT(&self->on_receive_settings_, OnReceiveSettings, self,
-                        grpc_schedule_on_exec_ctx);
-      grpc_chttp2_transport_start_reading(
-          self->result_->transport, args->read_buffer,
-          &self->on_receive_settings_, self->args_.interested_parties, nullptr);
-      self->timer_handle_ = self->event_engine_->RunAfter(
-          self->args_.deadline - Timestamp::Now(),
-          [self = self->RefAsSubclass<Chttp2Connector>()] {
-            ApplicationCallbackExecCtx callback_exec_ctx;
-            ExecCtx exec_ctx;
-            self->OnTimeout();
-          });
-    } else {
-      // If the handshaking succeeded but there is no endpoint, then the
-      // handshaker may have handed off the connection to some external
-      // code. Just verify that exit_early flag is set.
-      DCHECK(args->exit_early);
-      NullThenSchedClosure(DEBUG_LOCATION, &self->notify_, error);
+void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
+  MutexLock lock(&mu_);
+  if (!result.ok() || shutdown_) {
+    if (result.ok()) {
+      result = GRPC_ERROR_CREATE("connector shutdown");
     }
-    self->handshake_mgr_.reset();
+    result_->Reset();
+    NullThenSchedClosure(DEBUG_LOCATION, &notify_, result.status());
+  } else if ((*result)->endpoint != nullptr) {
+    result_->transport = grpc_create_chttp2_transport(
+        (*result)->args, std::move((*result)->endpoint), true);
+    CHECK_NE(result_->transport, nullptr);
+    result_->socket_node =
+        grpc_chttp2_transport_get_socket_node(result_->transport);
+    result_->channel_args = std::move((*result)->args);
+    Ref().release();  // Ref held by OnReceiveSettings()
+    GRPC_CLOSURE_INIT(&on_receive_settings_, OnReceiveSettings, this,
+                      grpc_schedule_on_exec_ctx);
+    grpc_chttp2_transport_start_reading(
+        result_->transport, (*result)->read_buffer.c_slice_buffer(),
+        &on_receive_settings_, args_.interested_parties, nullptr);
+    timer_handle_ = event_engine_->RunAfter(
+        args_.deadline - Timestamp::Now(),
+        [self = RefAsSubclass<Chttp2Connector>()]() mutable {
+          ApplicationCallbackExecCtx callback_exec_ctx;
+          ExecCtx exec_ctx;
+          self->OnTimeout();
+          // Ensure the Chttp2Connector is deleted under an ExecCtx.
+          self.reset();
+        });
+  } else {
+    // If the handshaking succeeded but there is no endpoint, then the
+    // handshaker may have handed off the connection to some external
+    // code. Just verify that exit_early flag is set.
+    DCHECK((*result)->exit_early);
+    NullThenSchedClosure(DEBUG_LOCATION, &notify_, result.status());
   }
-  self->Unref();
+  handshake_mgr_.reset();
 }
 
 void Chttp2Connector::OnReceiveSettings(void* arg, grpc_error_handle error) {
@@ -246,10 +236,8 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
       const grpc_resolved_address& address, const ChannelArgs& args) override {
     absl::StatusOr<ChannelArgs> new_args = GetSecureNamingChannelArgs(args);
     if (!new_args.ok()) {
-      gpr_log(GPR_ERROR,
-              "Failed to create channel args during subchannel creation: %s; "
-              "Got args: %s",
-              new_args.status().ToString().c_str(), args.ToString().c_str());
+      LOG(ERROR) << "Failed to create channel args during subchannel creation: "
+                 << new_args.status() << "; Got args: " << args.ToString();
       return nullptr;
     }
     RefCountedPtr<Subchannel> s = Subchannel::Create(
@@ -321,8 +309,9 @@ grpc_channel* grpc_channel_create(const char* target,
                                   grpc_channel_credentials* creds,
                                   const grpc_channel_args* c_args) {
   grpc_core::ExecCtx exec_ctx;
-  GRPC_API_TRACE("grpc_secure_channel_create(target=%s, creds=%p, args=%p)", 3,
-                 (target, (void*)creds, (void*)c_args));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_secure_channel_create(target=" << target
+      << ", creds=" << (void*)creds << ", args=" << (void*)c_args << ")";
   grpc_channel* channel = nullptr;
   grpc_error_handle error;
   if (creds != nullptr) {
@@ -361,9 +350,9 @@ grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
                                           grpc_channel_credentials* creds,
                                           const grpc_channel_args* args) {
   grpc_core::ExecCtx exec_ctx;
-  GRPC_API_TRACE(
-      "grpc_channel_create_from_fd(target=%p, fd=%d, creds=%p, args=%p)", 4,
-      (target, fd, creds, args));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_channel_create_from_fd(target=" << target << ", fd=" << fd
+      << ", creds=" << creds << ", args=" << args << ")";
   // For now, we only support insecure channel credentials.
   if (creds == nullptr ||
       creds->type() != grpc_core::InsecureCredentials::Type()) {
@@ -380,12 +369,12 @@ grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
 
   int flags = fcntl(fd, F_GETFL, 0);
   CHECK_EQ(fcntl(fd, F_SETFL, flags | O_NONBLOCK), 0);
-  grpc_endpoint* client = grpc_tcp_create_from_fd(
+  grpc_core::OrphanablePtr<grpc_endpoint> client(grpc_tcp_create_from_fd(
       grpc_fd_create(fd, "client", true),
       grpc_event_engine::experimental::ChannelArgsEndpointConfig(final_args),
-      "fd-client");
+      "fd-client"));
   grpc_core::Transport* transport =
-      grpc_create_chttp2_transport(final_args, client, true);
+      grpc_create_chttp2_transport(final_args, std::move(client), true);
   CHECK(transport);
   auto channel = grpc_core::ChannelCreate(
       target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -41,7 +41,7 @@ class Chttp2Connector : public SubchannelConnector {
   void Shutdown(grpc_error_handle error) override;
 
  private:
-  static void OnHandshakeDone(void* arg, grpc_error_handle error);
+  void OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result);
   static void OnReceiveSettings(void* arg, grpc_error_handle error);
   void OnTimeout() ABSL_LOCKS_EXCLUDED(mu_);