grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/lib/event_engine/posix_engine/posix_engine.h

@@ -48,13 +48,6 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #endif  // GRPC_POSIX_SOCKET_TCP
 
-#if defined(GRPC_POSIX_SOCKET_TCP) && \
-    !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING true
-#else
-#define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING false
-#endif
-
 namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
@@ -127,10 +120,10 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
 
   ~PosixEventEngine() override;
 
-  std::unique_ptr<EventEngine::Endpoint> CreatePosixEndpointFromFd(
-      int fd, const EndpointConfig& config,
-      MemoryAllocator memory_allocator) override;
-  std::unique_ptr<EventEngine::Endpoint> CreateEndpointFromFd(
+  absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>
+  CreatePosixEndpointFromFd(int fd, const EndpointConfig& config,
+                            MemoryAllocator memory_allocator) override;
+  absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> CreateEndpointFromFd(
       int fd, const EndpointConfig& config) override;
 
   ConnectionHandle CreateEndpointFromUnconnectedFd(
@@ -194,19 +187,14 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
 
   PosixEventEngine();
 
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+#ifdef GRPC_POSIX_SOCKET_TCP
   // Constructs an EventEngine which has a shared ownership of the poller. Use
   // the MakeTestOnlyPosixEventEngine static method to call this. Its expected
   // to be used only in tests.
   explicit PosixEventEngine(
       std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
           poller);
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 
-  EventEngine::TaskHandle RunAfterInternal(Duration when,
-                                           absl::AnyInvocable<void()> cb);
-
-#ifdef GRPC_POSIX_SOCKET_TCP
   friend class AsyncConnect;
   struct ConnectionShard {
     grpc_core::Mutex mu;
@@ -214,40 +202,8 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
         ABSL_GUARDED_BY(&mu);
   };
 
-  ConnectionHandle CreateEndpointFromUnconnectedFdInternal(
-      const FileDescriptor& fd, EventEngine::OnConnectCallback on_connect,
-      const EventEngine::ResolvedAddress& addr, const PosixTcpOptions& options,
-      MemoryAllocator memory_allocator, EventEngine::Duration timeout);
-
   void OnConnectFinishInternal(int connection_handle);
 
-  std::vector<ConnectionShard> connection_shards_;
-  std::atomic<int64_t> last_connection_id_{1};
-
-#endif  // GRPC_POSIX_SOCKET_TCP
-
-#if GRPC_ENABLE_FORK_SUPPORT
-  void AfterForkInChild();
-#endif
-
-  grpc_core::Mutex mu_;
-  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
-  std::atomic<intptr_t> aba_token_{0};
-#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
-
-  void RegisterAresResolverForFork(AresResolver* resolver);
-
-#if GRPC_ENABLE_FORK_SUPPORT
-  // A separate mutex to avoid deadlocks.
-  grpc_core::Mutex resolver_handles_mu_;
-  absl::InlinedVector<std::weak_ptr<AresResolver::ReinitHandle>, 16>
-      resolver_handles_ ABSL_GUARDED_BY(resolver_handles_mu_);
-#endif  // GRPC_ENABLE_FORK_SUPPORT
-#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
-  std::shared_ptr<ThreadPool> executor_;
-
-#if GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
-
   // RAII wrapper for a polling cycle. Starts a new one in ctor and stops
   // in dtor.
   class PollingCycle {
@@ -272,18 +228,41 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport {
   void SchedulePoller();
   void ResetPollCycle();
 
-  PosixEventPoller* GetPollerChecked() const {
-    CHECK_NE(poller_, nullptr);
-    return poller_.get();
-  }
+  ConnectionHandle CreateEndpointFromUnconnectedFdInternal(
+      const FileDescriptor& fd, EventEngine::OnConnectCallback on_connect,
+      const EventEngine::ResolvedAddress& addr, const PosixTcpOptions& options,
+      MemoryAllocator memory_allocator, EventEngine::Duration timeout);
 
+  std::vector<ConnectionShard> connection_shards_;
+  std::atomic<int64_t> last_connection_id_{1};
   std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller> poller_;
 
   // Ensures there's ever only one of these.
   std::optional<PollingCycle> polling_cycle_ ABSL_GUARDED_BY(&mu_);
+#endif  // GRPC_POSIX_SOCKET_TCP
 
-#endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           absl::AnyInvocable<void()> cb);
 
+#if GRPC_ENABLE_FORK_SUPPORT
+  void AfterForkInChild();
+#endif
+
+  grpc_core::Mutex mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
+  std::atomic<intptr_t> aba_token_{0};
+#if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+
+  void RegisterAresResolverForFork(AresResolver* resolver);
+
+#if GRPC_ENABLE_FORK_SUPPORT
+  // A separate mutex to avoid deadlocks.
+  grpc_core::Mutex resolver_handles_mu_;
+  absl::InlinedVector<std::weak_ptr<AresResolver::ReinitHandle>, 16>
+      resolver_handles_ ABSL_GUARDED_BY(resolver_handles_mu_);
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+#endif  // GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
+  std::shared_ptr<ThreadPool> executor_;
   std::shared_ptr<TimerManager> timer_manager_;
 };
 

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.cc

@@ -33,7 +33,6 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -44,7 +43,9 @@
 #include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/iomgr/socket_mutator.h"
 #include "src/core/net/socket_mutator.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/time.h"
@@ -77,7 +78,7 @@ absl::StatusOr<int> PosixEngineListenerImpl::Bind(
   EventEngine::ResolvedAddress res_addr = addr;
   EventEngine::ResolvedAddress addr6_v4mapped;
   int requested_port = ResolvedAddressGetPort(res_addr);
-  CHECK(addr.size() <= EventEngine::ResolvedAddress::MAX_SIZE_BYTES);
+  GRPC_CHECK(addr.size() <= EventEngine::ResolvedAddress::MAX_SIZE_BYTES);
   UnlinkIfUnixDomainSocket(addr);
 
   EventEnginePosixInterface& posix_interface = poller_->posix_interface();
@@ -307,7 +308,7 @@ void PosixEngineListenerImpl::AsyncConnectionAcceptor::Shutdown() {
 absl::Status PosixEngineListenerImpl::Start() {
   grpc_core::MutexLock lock(&this->mu_);
   // Start each asynchronous acceptor.
-  CHECK(!this->started_);
+  GRPC_CHECK(!this->started_);
   this->started_ = true;
   for (auto it = acceptors_.begin(); it != acceptors_.end(); it++) {
     (*it)->Start();

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.cc

@@ -24,7 +24,6 @@
 #include <string>
 
 #include "absl/cleanup/cleanup.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -33,6 +32,7 @@
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"  // IWYU pragma: keep
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
@@ -68,7 +68,7 @@ absl::Status PrepareSocket(EventEnginePosixInterface* posix_interface,
                            const PosixTcpOptions& options,
                            ListenerSocket& socket) {
   FileDescriptor fd = socket.sock;
-  CHECK(fd.ready());
+  GRPC_CHECK(fd.ready());
   bool close_fd = true;
   socket.port = 0;
   auto sock_cleanup =
@@ -110,7 +110,7 @@ absl::StatusOr<ListenerSocket> CreateAndPrepareListenerSocket(
     socket.addr = addr;
   }
   GRPC_RETURN_IF_ERROR(PrepareSocket(posix_interface, options, socket));
-  CHECK_GT(socket.port, 0);
+  GRPC_CHECK_GT(socket.port, 0);
   return socket;
 }
 
@@ -269,8 +269,8 @@ absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
     }
     return assigned_port;
   } else {
-    CHECK(!v6_sock.ok());
-    CHECK(!v4_sock.ok());
+    GRPC_CHECK(!v6_sock.ok());
+    GRPC_CHECK(!v4_sock.ok());
     return absl::FailedPreconditionError(absl::StrCat(
         "Failed to add any wildcard listeners: ", v6_sock.status().message(),
         v4_sock.status().message()));

data/src/core/lib/event_engine/posix_engine/posix_interface.h

@@ -23,10 +23,10 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "src/core/lib/event_engine/posix_engine/file_descriptor_collection.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.cc

@@ -41,7 +41,7 @@
 
 #include <cstring>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 #ifdef GPR_WINDOWS

data/src/core/lib/event_engine/posix_engine/timer_manager.cc

@@ -25,10 +25,10 @@
 #include <optional>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/time/time.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/util/grpc_check.h"
 
 static thread_local bool g_timer_thread;
 
@@ -65,7 +65,7 @@ void TimerManager::MainLoop() {
   grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
   std::optional<std::vector<experimental::EventEngine::Closure*>> check_result =
       timer_list_->TimerCheck(&next);
-  CHECK(check_result.has_value())
+  GRPC_CHECK(check_result.has_value())
       << "ERROR: More than one MainLoop is running.";
   bool timers_found = !check_result->empty();
   if (timers_found) {
@@ -126,7 +126,7 @@ void TimerManager::Kick() {
 
 void TimerManager::RestartPostFork() {
   grpc_core::MutexLock lock(&mu_);
-  CHECK(state_ != TimerManager::State::kRunning);
+  GRPC_CHECK(state_ != TimerManager::State::kRunning);
   GRPC_TRACE_VLOG(timer, 2)
       << "TimerManager::" << this << " restarting after suspend";
   if (state_ == TimerManager::State::kSuspended) {

data/src/core/lib/event_engine/resolved_address.cc

@@ -18,8 +18,8 @@
 #include <grpc/support/port_platform.h>
 #include <string.h>
 
-#include "absl/log/check.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/util/grpc_check.h"
 
 // IWYU pragma: no_include <sys/socket.h>
 
@@ -28,8 +28,8 @@ namespace grpc_event_engine::experimental {
 EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
                                               socklen_t size)
     : size_(size) {
-  DCHECK_GE(size, 0u);
-  CHECK(static_cast<size_t>(size) <= sizeof(address_));
+  GRPC_DCHECK_GE(size, 0u);
+  GRPC_CHECK(static_cast<size_t>(size) <= sizeof(address_));
   memcpy(&address_, address, size);
 }
 

data/src/core/lib/event_engine/shim.cc

@@ -22,17 +22,13 @@
 namespace grpc_event_engine::experimental {
 
 bool UseEventEngineClient() {
-#if defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-  return false;
-#endif
-  return grpc_core::IsEventEngineClientEnabled();
+  return !EventEngineExperimentDisabledForPython() &&
+         grpc_core::IsEventEngineClientEnabled();
 }
 
 bool UseEventEngineListener() {
-#if defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
-  return false;
-#endif
-  return grpc_core::IsEventEngineListenerEnabled();
+  return !EventEngineExperimentDisabledForPython() &&
+         grpc_core::IsEventEngineListenerEnabled();
 }
 
 bool UsePollsetAlternative() {
@@ -40,10 +36,11 @@ bool UsePollsetAlternative() {
          grpc_core::IsPollsetAlternativeEnabled();
 }
 
-// Returns true if GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER is defined.
+// Returns true if the poller is disabled by build configuration or experiment
+// flags.
 bool EventEngineExperimentDisabledForPython() {
-#ifdef GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER
-  return true;
+#ifdef GRPC_PYTHON_BUILD
+  return !grpc_core::IsEventEnginePollerForPythonEnabled();
 #else
   return false;
 #endif

data/src/core/lib/event_engine/shim.h

@@ -35,7 +35,8 @@ bool UseEventEngineListener();
 // may disable the poller in some builds.
 bool UsePollsetAlternative();
 
-// Returns true if GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER is defined.
+// Returns true if the poller is disabled by build configuration or experiment
+// flags.
 bool EventEngineExperimentDisabledForPython();
 
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/slice.cc

@@ -22,9 +22,9 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -46,7 +46,7 @@ Slice CopyConstructors<Slice>::FromCopiedString(std::string s) {
 
 MutableSlice::MutableSlice(const grpc_slice& slice)
     : slice_detail::BaseSlice(slice) {
-  DCHECK(slice.refcount == nullptr || slice.refcount->IsUnique());
+  GRPC_DCHECK(slice.refcount == nullptr || slice.refcount->IsUnique());
 }
 
 MutableSlice::~MutableSlice() { grpc_core::CSliceUnref(c_slice()); }

data/src/core/lib/event_engine/tcp_socket_utils.cc

@@ -53,12 +53,12 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/uri.h"
@@ -216,7 +216,7 @@ bool ResolvedAddressIsV4Mapped(
 bool ResolvedAddressToV4Mapped(
     const EventEngine::ResolvedAddress& resolved_addr,
     EventEngine::ResolvedAddress* resolved_addr6_out) {
-  CHECK(&resolved_addr != resolved_addr6_out);
+  GRPC_CHECK(&resolved_addr != resolved_addr6_out);
   const sockaddr* addr = resolved_addr.address();
   sockaddr_in6* addr6_out = const_cast<sockaddr_in6*>(
       reinterpret_cast<const sockaddr_in6*>(resolved_addr6_out->address()));
@@ -238,8 +238,8 @@ EventEngine::ResolvedAddress ResolvedAddressMakeWild6(int port) {
   EventEngine::ResolvedAddress resolved_wild_out;
   sockaddr_in6* wild_out = reinterpret_cast<sockaddr_in6*>(
       const_cast<sockaddr*>(resolved_wild_out.address()));
-  CHECK_GE(port, 0);
-  CHECK_LT(port, 65536);
+  GRPC_CHECK_GE(port, 0);
+  GRPC_CHECK_LT(port, 65536);
   memset(wild_out, 0, sizeof(sockaddr_in6));
   wild_out->sin6_family = AF_INET6;
   wild_out->sin6_port = htons(static_cast<uint16_t>(port));
@@ -252,8 +252,8 @@ EventEngine::ResolvedAddress ResolvedAddressMakeWild4(int port) {
   EventEngine::ResolvedAddress resolved_wild_out;
   sockaddr_in* wild_out = reinterpret_cast<sockaddr_in*>(
       const_cast<sockaddr*>(resolved_wild_out.address()));
-  CHECK_GE(port, 0);
-  CHECK_LT(port, 65536);
+  GRPC_CHECK_GE(port, 0);
+  GRPC_CHECK_LT(port, 65536);
   memset(wild_out, 0, sizeof(sockaddr_in));
   wild_out->sin_family = AF_INET;
   wild_out->sin_port = htons(static_cast<uint16_t>(port));
@@ -289,14 +289,14 @@ void ResolvedAddressSetPort(EventEngine::ResolvedAddress& resolved_addr,
   sockaddr* addr = const_cast<sockaddr*>(resolved_addr.address());
   switch (addr->sa_family) {
     case AF_INET:
-      CHECK_GE(port, 0);
-      CHECK_LT(port, 65536);
+      GRPC_CHECK_GE(port, 0);
+      GRPC_CHECK_LT(port, 65536);
       (reinterpret_cast<sockaddr_in*>(addr))->sin_port =
           htons(static_cast<uint16_t>(port));
       return;
     case AF_INET6:
-      CHECK_GE(port, 0);
-      CHECK_LT(port, 65536);
+      GRPC_CHECK_GE(port, 0);
+      GRPC_CHECK_LT(port, 65536);
       (reinterpret_cast<sockaddr_in6*>(addr))->sin6_port =
           htons(static_cast<uint16_t>(port));
       return;
@@ -441,7 +441,7 @@ absl::StatusOr<EventEngine::ResolvedAddress> URIToResolvedAddress(
     LOG(ERROR) << "Failed to parse URI. Error: " << uri.status();
   }
   GRPC_RETURN_IF_ERROR(uri.status());
-  CHECK(grpc_parse_uri(*uri, &addr));
+  GRPC_CHECK(grpc_parse_uri(*uri, &addr));
   return EventEngine::ResolvedAddress(
       reinterpret_cast<const sockaddr*>(addr.addr), addr.len);
 }

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.cc

@@ -29,7 +29,6 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
@@ -42,6 +41,7 @@
 #include "src/core/util/crash.h"
 #include "src/core/util/env.h"
 #include "src/core/util/examine_stack.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/thd.h"
 #include "src/core/util/time.h"
 
@@ -180,7 +180,7 @@ WorkStealingThreadPool::WorkStealingThreadPool(size_t reserve_threads)
 void WorkStealingThreadPool::Quiesce() { pool_->Quiesce(); }
 
 WorkStealingThreadPool::~WorkStealingThreadPool() {
-  CHECK(pool_->IsQuiesced());
+  GRPC_CHECK(pool_->IsQuiesced());
 }
 
 void WorkStealingThreadPool::Run(absl::AnyInvocable<void()> callback) {
@@ -237,7 +237,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Start() {
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Run(
     EventEngine::Closure* closure) {
-  CHECK(!IsQuiesced());
+  GRPC_CHECK(!IsQuiesced());
   if (g_local_queue != nullptr && g_local_queue->owner() == this) {
     g_local_queue->Add(closure);
   } else {
@@ -279,7 +279,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
   if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
     DumpStacksAndCrash();
   }
-  CHECK(queue_.Empty());
+  GRPC_CHECK(queue_.Empty());
   quiesced_.store(true, std::memory_order_relaxed);
   grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
   lifeguard_.reset();
@@ -293,14 +293,14 @@ bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetThrottled(
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetShutdown(
     bool is_shutdown) {
   auto was_shutdown = shutdown_.exchange(is_shutdown);
-  CHECK(is_shutdown != was_shutdown);
+  GRPC_CHECK(is_shutdown != was_shutdown);
   work_signal_.SignalAll();
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetForking(
     bool is_forking) {
   auto was_forking = forking_.exchange(is_forking);
-  CHECK(is_forking != was_forking);
+  GRPC_CHECK(is_forking != was_forking);
 }
 
 bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::IsForking() {
@@ -510,7 +510,7 @@ void WorkStealingThreadPool::ThreadState::ThreadBody() {
   } else if (pool_->IsShutdown()) {
     FinishDraining();
   }
-  CHECK(g_local_queue->Empty());
+  GRPC_CHECK(g_local_queue->Empty());
   pool_->theft_registry()->Unenroll(g_local_queue);
   delete g_local_queue;
   if (g_log_verbose_failures) {