grpc 1.75.0 → 1.78.1

data/src/core/ext/transport/chttp2/alpn/alpn.cc

@@ -20,7 +20,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/useful.h"
 
 // in order of preference
@@ -42,6 +42,6 @@ size_t grpc_chttp2_num_alpn_versions(void) {
 }
 
 const char* grpc_chttp2_get_alpn_version_index(size_t i) {
-  CHECK_LT(i, GPR_ARRAY_SIZE(supported_versions));
+  GRPC_CHECK_LT(i, GPR_ARRAY_SIZE(supported_versions));
   return supported_versions[i];
 }

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

@@ -34,11 +34,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/str_format.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/client_channel_filter.h"
@@ -49,6 +44,10 @@
 #include "src/core/credentials/transport/security_connector.h"
 #include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
 #ifndef GRPC_EXPERIMENTAL_TEMPORARILY_DISABLE_PH2
 // GRPC_EXPERIMENTAL_TEMPORARILY_DISABLE_PH2 is a temporary fix to help
 // some customers who are having severe memory constraints. This macro
@@ -77,6 +76,7 @@
 #include "src/core/resolver/resolver_registry.h"
 #include "src/core/transport/endpoint_transport_client_channel_factory.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time.h"
@@ -93,6 +93,9 @@
 
 namespace grpc_core {
 
+#define GRPC_HTTP2_CONNECTOR_DLOG \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
 using ::grpc_event_engine::experimental::EventEngine;
 
 namespace {
@@ -108,7 +111,7 @@ void Chttp2Connector::Connect(const Args& args, Result* result,
                               grpc_closure* notify) {
   {
     MutexLock lock(&mu_);
-    CHECK_EQ(notify_, nullptr);
+    GRPC_CHECK_EQ(notify_, nullptr);
     args_ = args;
     result_ = result;
     notify_ = notify;
@@ -169,19 +172,24 @@ void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
     result_->Reset();
     NullThenSchedClosure(DEBUG_LOCATION, &notify_, result.status());
   } else if ((*result)->endpoint != nullptr) {
+    GRPC_HTTP2_CONNECTOR_DLOG
+        << "Chttp2Connector::OnHandshakeDone handshake succeeded with endpoint";
     const bool is_callv1 =
         !((*result)->args.GetBool(GRPC_ARG_USE_V3_STACK).value_or(false));
     if (is_callv1) {
+      GRPC_HTTP2_CONNECTOR_DLOG
+          << "Chttp2Connector::OnHandshakeDone creating chttp2 transport";
       result_->transport = grpc_create_chttp2_transport(
           (*result)->args, std::move((*result)->endpoint), true);
-      CHECK_NE(result_->transport, nullptr);
+      GRPC_CHECK_NE(result_->transport, nullptr);
       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);
+          [self = RefAsSubclass<Chttp2Connector>()](
+              absl::StatusOr<uint32_t> max_concurrent_streams) {
+            self->OnReceiveSettings(max_concurrent_streams);
+          },
+          args_.interested_parties, nullptr);
       timer_handle_ = event_engine_->RunAfter(
           args_.deadline - Timestamp::Now(),
           [self = RefAsSubclass<Chttp2Connector>()]() mutable {
@@ -199,6 +207,8 @@ void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
     }
 #else
     } else {
+      GRPC_HTTP2_CONNECTOR_DLOG
+          << "Chttp2Connector::OnHandshakeDone creating PH2 transport";
       // TODO(tjagtap) : [PH2][P1] : Validate this code block thoroughly once
       // the ping pong test is in place.
       std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
@@ -217,14 +227,18 @@ void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
               (*result)
                   ->args
                   .GetObjectRef<grpc_event_engine::experimental::EventEngine>();
-      Ref().release();  // Ref held by OnReceiveSettings()
-      GRPC_CLOSURE_INIT(&on_receive_settings_, OnReceiveSettings, this,
-                        grpc_schedule_on_exec_ctx);
+      // Http2ClientTransport does not take ownership of the channel args.
+      http2::Http2ClientTransport* client_transport =
+          new http2::Http2ClientTransport(
+              std::move(promise_endpoint), (*result)->args, event_engine_ptr,
+              [self = RefAsSubclass<Chttp2Connector>()](
+                  absl::StatusOr<uint32_t> max_concurrent_streams) {
+                self->OnReceiveSettings(max_concurrent_streams);
+              });
+      GRPC_DCHECK_NE(client_transport, nullptr);
+      result_->transport = client_transport;
       result_->channel_args = std::move((*result)->args);
-      result_->transport = new http2::Http2ClientTransport(
-          std::move(promise_endpoint), (*result)->args, event_engine_ptr,
-          &on_receive_settings_);
-      DCHECK_NE(result_->transport, nullptr);
+      client_transport->SpawnTransportLoops();
       timer_handle_ = event_engine_->RunAfter(
           args_.deadline - Timestamp::Now(),
           [self = RefAsSubclass<Chttp2Connector>()]() mutable {
@@ -239,37 +253,37 @@ void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
     // 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);
+    GRPC_DCHECK((*result)->exit_early);
     NullThenSchedClosure(DEBUG_LOCATION, &notify_, result.status());
   }
   handshake_mgr_.reset();
 }
 
-void Chttp2Connector::OnReceiveSettings(void* arg, grpc_error_handle error) {
-  Chttp2Connector* self = static_cast<Chttp2Connector*>(arg);
-  {
-    MutexLock lock(&self->mu_);
-    if (!self->notify_error_.has_value()) {
-      if (!error.ok()) {
-        // Transport got an error while waiting on SETTINGS frame.
-        self->result_->Reset();
-      }
-      self->MaybeNotify(error);
-      if (self->timer_handle_.has_value()) {
-        if (self->event_engine_->Cancel(*self->timer_handle_)) {
-          // If we have cancelled the timer successfully, call Notify() again
-          // since the timer callback will not be called now.
-          self->MaybeNotify(absl::OkStatus());
-        }
-        self->timer_handle_.reset();
+void Chttp2Connector::OnReceiveSettings(
+    absl::StatusOr<uint32_t> max_concurrent_streams) {
+  MutexLock lock(&mu_);
+  if (max_concurrent_streams.ok()) {
+    result_->max_concurrent_streams = *max_concurrent_streams;
+  }
+  if (!notify_error_.has_value()) {
+    if (!max_concurrent_streams.ok()) {
+      // Transport got an error while waiting on SETTINGS frame.
+      result_->Reset();
+    }
+    MaybeNotify(max_concurrent_streams.status());
+    if (timer_handle_.has_value()) {
+      if (event_engine_->Cancel(*timer_handle_)) {
+        // If we have cancelled the timer successfully, call Notify() again
+        // since the timer callback will not be called now.
+        MaybeNotify(absl::OkStatus());
       }
-    } else {
-      // OnTimeout() was already invoked. Call Notify() again so that notify_
-      // can be invoked.
-      self->MaybeNotify(absl::OkStatus());
+      timer_handle_.reset();
     }
+  } else {
+    // OnTimeout() was already invoked. Call Notify() again so that notify_
+    // can be invoked.
+    MaybeNotify(absl::OkStatus());
   }
-  self->Unref();
 }
 
 void Chttp2Connector::OnTimeout() {
@@ -347,14 +361,14 @@ grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
           .SetObject(creds->Ref());
 
   int flags = fcntl(fd, F_GETFL, 0);
-  CHECK_EQ(fcntl(fd, F_SETFL, flags | O_NONBLOCK), 0);
+  GRPC_CHECK_EQ(fcntl(fd, F_SETFL, flags | O_NONBLOCK), 0);
   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"));
   grpc_core::Transport* transport =
       grpc_create_chttp2_transport(final_args, std::move(client), true);
-  CHECK(transport);
+  GRPC_CHECK(transport);
   auto channel = grpc_core::ChannelCreate(
       target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
   if (channel.ok()) {
@@ -376,7 +390,7 @@ grpc_channel* grpc_channel_create_from_fd(const char* /* target */,
                                           int /* fd */,
                                           grpc_channel_credentials* /* creds*/,
                                           const grpc_channel_args* /* args */) {
-  CHECK(0);
+  GRPC_CHECK(0);
   return nullptr;
 }
 

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

@@ -24,7 +24,6 @@
 
 #include <optional>
 
-#include "absl/base/thread_annotations.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -32,6 +31,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
 
 namespace grpc_core {
 
@@ -42,7 +42,7 @@ class Chttp2Connector : public SubchannelConnector {
 
  private:
   void OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result);
-  static void OnReceiveSettings(void* arg, grpc_error_handle error);
+  void OnReceiveSettings(absl::StatusOr<uint32_t> max_concurrent_streams);
   void OnTimeout() ABSL_LOCKS_EXCLUDED(mu_);
 
   // We cannot invoke notify_ until both OnTimeout() and OnReceiveSettings()
@@ -61,7 +61,6 @@ class Chttp2Connector : public SubchannelConnector {
   Result* result_ = nullptr;
   grpc_closure* notify_ = nullptr;
   bool shutdown_ = false;
-  grpc_closure on_receive_settings_;
   std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       timer_handle_ ABSL_GUARDED_BY(mu_);
   // A raw pointer will suffice since args_ holds a copy of the ChannelArgs

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

@@ -37,15 +37,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
-#include "absl/strings/strip.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/transport/insecure/insecure_credentials.h"
@@ -83,6 +74,7 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -91,6 +83,14 @@
 #include "src/core/util/time.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/uri.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -207,16 +207,14 @@ void NewChttp2ServerListener::ActiveConnection::HandshakingState::
 }
 
 void NewChttp2ServerListener::ActiveConnection::HandshakingState::
-    OnReceiveSettings(void* arg, grpc_error_handle /* error */) {
-  HandshakingState* self = static_cast<HandshakingState*>(arg);
-  self->connection_->work_serializer_.Run(
-      [self] {
+    OnReceiveSettings() {
+  connection_->work_serializer_.Run(
+      [self = Ref()] {
         if (self->timer_handle_.has_value()) {
           self->connection_->listener_state_->event_engine()->Cancel(
               *self->timer_handle_);
           self->timer_handle_.reset();
         }
-        self->Unref();
       },
       DEBUG_LOCATION);
 }
@@ -240,15 +238,15 @@ void NewChttp2ServerListener::ActiveConnection::HandshakingState::
       // handshake deadline.
       connection_->state_ =
           DownCast<grpc_chttp2_transport*>(transport.get())->Ref();
-      Ref().release();  // Held by OnReceiveSettings().
-      GRPC_CLOSURE_INIT(&on_receive_settings_, OnReceiveSettings, this,
-                        grpc_schedule_on_exec_ctx);
       grpc_closure* on_close = &connection_->on_close_;
       // Refs held by OnClose()
       connection_->Ref().release();
       grpc_chttp2_transport_start_reading(
           transport.get(), (*result)->read_buffer.c_slice_buffer(),
-          &on_receive_settings_, nullptr, on_close);
+          [self = Ref()](absl::StatusOr<uint32_t>) {
+            self->OnReceiveSettings();
+          },
+          nullptr, on_close);
       timer_handle_ = connection_->listener_state_->event_engine()->RunAfter(
           deadline_ - Timestamp::Now(), [self = Ref()]() mutable {
             // HandshakingState deletion might require an active ExecCtx.
@@ -521,7 +519,7 @@ void NewChttp2ServerListener::Start() {
       LOG(ERROR) << "Error adding port to server: " << StatusToString(error);
       // TODO(yashykt): We wouldn't need to assert here if we bound to the
       // port earlier during AddPort.
-      CHECK(0);
+      GRPC_CHECK(0);
     }
   }
   if (tcp_server != nullptr) {
@@ -692,7 +690,7 @@ absl::StatusOr<int> Chttp2ServerAddPort(Server* server, const char* addr,
         if (port_num == -1) {
           port_num = port_temp;
         } else {
-          CHECK(port_num == port_temp);
+          GRPC_CHECK(port_num == port_temp);
         }
       }
     }
@@ -722,7 +720,7 @@ namespace experimental {
 
 absl::Status PassiveListenerImpl::AcceptConnectedEndpoint(
     std::unique_ptr<EventEngine::Endpoint> endpoint) {
-  CHECK_NE(server_.get(), nullptr);
+  GRPC_CHECK_NE(server_.get(), nullptr);
   RefCountedPtr<NewChttp2ServerListener> new_listener;
   {
     MutexLock lock(&mu_);
@@ -742,7 +740,7 @@ absl::Status PassiveListenerImpl::AcceptConnectedEndpoint(
 }
 
 absl::Status PassiveListenerImpl::AcceptConnectedFd(int fd) {
-  CHECK_NE(server_.get(), nullptr);
+  GRPC_CHECK_NE(server_.get(), nullptr);
   ExecCtx exec_ctx;
   auto& args = server_->channel_args();
   auto* supports_fd = QueryExtension<EventEngineSupportsFdExtension>(
@@ -754,7 +752,10 @@ absl::Status PassiveListenerImpl::AcceptConnectedFd(int fd) {
   }
   auto endpoint =
       supports_fd->CreateEndpointFromFd(fd, ChannelArgsEndpointConfig(args));
-  return AcceptConnectedEndpoint(std::move(endpoint));
+  if (!endpoint.ok()) {
+    return std::move(endpoint).status();
+  }
+  return AcceptConnectedEndpoint(std::move(endpoint).value());
 }
 
 void PassiveListenerImpl::ListenerDestroyed() {
@@ -809,7 +810,7 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
 
 void grpc_server_add_channel_from_fd(grpc_server* /* server */, int /* fd */,
                                      grpc_server_credentials* /* creds */) {
-  CHECK(0);
+  GRPC_CHECK(0);
 }
 
 #endif  // GPR_SUPPORT_CHANNELS_FROM_FD

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

@@ -83,7 +83,7 @@ class NewChttp2ServerListener : public Server::ListenerInterface {
       friend class grpc_core::testing::HandshakingStateTestPeer;
 
       void OnTimeoutLocked();
-      static void OnReceiveSettings(void* arg, grpc_error_handle /* error */);
+      void OnReceiveSettings();
       void OnHandshakeDoneLocked(absl::StatusOr<HandshakerArgs*> result);
 
       RefCountedPtr<ActiveConnection> const connection_;
@@ -98,7 +98,6 @@ class NewChttp2ServerListener : public Server::ListenerInterface {
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
       std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
           timer_handle_;
-      grpc_closure on_receive_settings_;
     };
 
     ActiveConnection(RefCountedPtr<Server::ListenerState> listener_state,

data/src/core/ext/transport/chttp2/transport/bin_decoder.cc

@@ -21,10 +21,10 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/slice/slice.h"
+#include "src/core/util/grpc_check.h"
 #include "absl/base/attributes.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
-#include "src/core/lib/slice/slice.h"
 
 static uint8_t decode_table[] = {
     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
@@ -191,8 +191,8 @@ grpc_slice grpc_chttp2_base64_decode(const grpc_slice& input) {
     grpc_core::CSliceUnref(output);
     return grpc_empty_slice();
   }
-  CHECK(ctx.output_cur == GRPC_SLICE_END_PTR(output));
-  CHECK(ctx.input_cur == GRPC_SLICE_END_PTR(input));
+  GRPC_CHECK(ctx.output_cur == GRPC_SLICE_END_PTR(output));
+  GRPC_CHECK(ctx.input_cur == GRPC_SLICE_END_PTR(input));
   return output;
 }
 
@@ -234,7 +234,7 @@ grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
     grpc_core::CSliceUnref(output);
     return grpc_empty_slice();
   }
-  CHECK(ctx.output_cur == GRPC_SLICE_END_PTR(output));
-  CHECK(ctx.input_cur <= GRPC_SLICE_END_PTR(input));
+  GRPC_CHECK(ctx.output_cur == GRPC_SLICE_END_PTR(output));
+  GRPC_CHECK(ctx.input_cur <= GRPC_SLICE_END_PTR(input));
   return output;
 }

data/src/core/ext/transport/chttp2/transport/bin_encoder.cc

@@ -22,8 +22,8 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "absl/log/check.h"
 #include "src/core/ext/transport/chttp2/transport/huffsyms.h"
+#include "src/core/util/grpc_check.h"
 
 static const char alphabet[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -86,8 +86,8 @@ grpc_slice grpc_chttp2_base64_encode(const grpc_slice& input) {
       break;
   }
 
-  CHECK(out == (char*)GRPC_SLICE_END_PTR(output));
-  CHECK(in == GRPC_SLICE_END_PTR(input));
+  GRPC_CHECK(out == (char*)GRPC_SLICE_END_PTR(output));
+  GRPC_CHECK(in == GRPC_SLICE_END_PTR(input));
   return output;
 }
 
@@ -130,7 +130,7 @@ grpc_slice grpc_chttp2_huffman_compress(const grpc_slice& input) {
                              static_cast<uint8_t>(0xffu >> temp_length));
   }
 
-  CHECK(out == GRPC_SLICE_END_PTR(output));
+  GRPC_CHECK(out == GRPC_SLICE_END_PTR(output));
 
   return output;
 }
@@ -226,9 +226,9 @@ grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
         static_cast<uint8_t>(0xffu >> out.temp_length));
   }
 
-  CHECK(out.out <= GRPC_SLICE_END_PTR(output));
+  GRPC_CHECK(out.out <= GRPC_SLICE_END_PTR(output));
   GRPC_SLICE_SET_LENGTH(output, out.out - start_out);
 
-  CHECK(in == GRPC_SLICE_END_PTR(input));
+  GRPC_CHECK(in == GRPC_SLICE_END_PTR(input));
   return output;
 }