grpc 1.63.0 → 1.65.2

data/src/core/lib/event_engine/windows/windows_engine.h

@@ -44,8 +44,6 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-// TODO(ctiller): KeepsGrpcInitialized is an interim measure to ensure that
-// EventEngine is shut down before we shut down iomgr.
 class WindowsEventEngine : public EventEngine,
                            public grpc_core::KeepsGrpcInitialized {
  public:
@@ -105,24 +103,133 @@ class WindowsEventEngine : public EventEngine,
   IOCP* poller() { return &iocp_; }
 
  private:
-  // State of an active connection.
-  // Managed by a shared_ptr, owned exclusively by the timeout callback and the
-  // OnConnectCompleted callback herein.
-  struct ConnectionState {
-    // everything is guarded by mu;
-    grpc_core::Mutex mu
+  // The state of an active connection.
+  //
+  // This object is managed by a shared_ptr, which is owned by:
+  //   1) the deadline timer callback, and
+  //   2) the OnConnectCompleted callback.
+  class ConnectionState : public std::enable_shared_from_this<ConnectionState> {
+   public:
+    ConnectionState(std::shared_ptr<WindowsEventEngine> engine,
+                    std::unique_ptr<WinSocket> socket,
+                    EventEngine::ResolvedAddress address,
+                    MemoryAllocator allocator,
+                    EventEngine::OnConnectCallback on_connect_user_callback);
+
+    // Starts the deadline timer, and sets up the socket to notify on writes.
+    //
+    // This cannot be done in the constructor since shared_from_this is required
+    // for the callbacks to hold a ref to this object.
+    void Start(Duration timeout) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+    // Returns the user's callback and resets it to nullptr to ensure it only
+    // runs once.
+    OnConnectCallback TakeCallback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+    // Create an Endpoint, transfering held object ownership to the endpoint.
+    //
+    // This can only be called once, and the connection state is no longer valid
+    // after an endpoint has been created. Callers must guarantee that the
+    // deadline timer callback will not be run.
+    std::unique_ptr<WindowsEndpoint> FinishConnectingAndMakeEndpoint(
+        ThreadPool* thread_pool) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+    // Release all refs to the on-connect callback.
+    void AbortOnConnect() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+    // Release all refs to the deadline timer callback.
+    void AbortDeadlineTimer() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+    // TODO(hork): this is unsafe. Whatever needs the socket should likely
+    // delegate responsibility to this object.
+    WinSocket* socket() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+      return socket_.get();
+    }
+
+    const EventEngine::ConnectionHandle& connection_handle() {
+      return connection_handle_;
+    }
+    const EventEngine::TaskHandle& timer_handle() { return timer_handle_; }
+
+    grpc_core::Mutex& mu() ABSL_LOCK_RETURNED(mu_) { return mu_; }
+
+   private:
+    // Required for the custom operator<< overload to see the private
+    // ConnectionState internal state.
+    friend std::ostream& operator<<(std::ostream& out,
+                                    const ConnectionState& connection_state)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state.mu_);
+
+    // Stateful closure for the endpoint's on-connect callback.
+    //
+    // Once created, this closure must be Run or deleted to release the held
+    // refs.
+    class OnConnectedCallback : public EventEngine::Closure {
+     public:
+      OnConnectedCallback(WindowsEventEngine* engine,
+                          std::shared_ptr<ConnectionState> connection_state)
+          : engine_(engine), connection_state_(std::move(connection_state)) {}
+
+      // Runs the WindowsEventEngine's OnConnectCompleted if the deadline timer
+      // hasn't fired first.
+      void Run() override;
+
+     private:
+      WindowsEventEngine* engine_;
+      std::shared_ptr<ConnectionState> connection_state_;
+    };
+
+    // Stateful closure for the deadline timer.
+    //
+    // Once created, this closure must be Run or deleted to release the held
+    // refs.
+    class DeadlineTimerCallback : public EventEngine::Closure {
+     public:
+      DeadlineTimerCallback(WindowsEventEngine* engine,
+                            std::shared_ptr<ConnectionState> connection_state)
+          : engine_(engine), connection_state_(std::move(connection_state)) {}
+
+      // Runs the WindowsEventEngine's OnDeadlineTimerFired if the deadline
+      // timer hasn't fired first.
+      void Run() override;
+
+     private:
+      WindowsEventEngine* engine_;
+      std::shared_ptr<ConnectionState> connection_state_;
+    };
+
+    // everything is guarded by mu_;
+    grpc_core::Mutex mu_
         ABSL_ACQUIRED_BEFORE(WindowsEventEngine::connection_mu_);
-    EventEngine::ConnectionHandle connection_handle ABSL_GUARDED_BY(mu);
-    EventEngine::TaskHandle timer_handle ABSL_GUARDED_BY(mu) =
+    // Endpoint connection state.
+    std::unique_ptr<WinSocket> socket_ ABSL_GUARDED_BY(mu_);
+    EventEngine::ResolvedAddress address_ ABSL_GUARDED_BY(mu_);
+    MemoryAllocator allocator_ ABSL_GUARDED_BY(mu_);
+    EventEngine::OnConnectCallback on_connect_user_callback_
+        ABSL_GUARDED_BY(mu_);
+    // This guarantees the EventEngine survives long enough to execute these
+    // deadline timer or on-connect callbacks.
+    std::shared_ptr<WindowsEventEngine> engine_ ABSL_GUARDED_BY(mu_);
+    // Owned closures. These hold refs to this object.
+    std::unique_ptr<OnConnectedCallback> on_connected_cb_ ABSL_GUARDED_BY(mu_);
+    std::unique_ptr<DeadlineTimerCallback> deadline_timer_cb_
+        ABSL_GUARDED_BY(mu_);
+    // Their respective method handles.
+    EventEngine::ConnectionHandle connection_handle_ ABSL_GUARDED_BY(mu_) =
+        EventEngine::ConnectionHandle::kInvalid;
+    EventEngine::TaskHandle timer_handle_ ABSL_GUARDED_BY(mu_) =
         EventEngine::TaskHandle::kInvalid;
-    EventEngine::OnConnectCallback on_connected_user_callback
-        ABSL_GUARDED_BY(mu);
-    EventEngine::Closure* on_connected ABSL_GUARDED_BY(mu);
-    std::unique_ptr<WinSocket> socket ABSL_GUARDED_BY(mu);
-    EventEngine::ResolvedAddress address ABSL_GUARDED_BY(mu);
-    MemoryAllocator allocator ABSL_GUARDED_BY(mu);
+    // Flag to ensure that only one of the even closures will complete its
+    // responsibilities.
+    bool has_run_ ABSL_GUARDED_BY(mu_) = false;
   };
 
+  // Required for the custom operator<< overload to see the private
+  // ConnectionState type.
+  friend std::ostream& operator<<(std::ostream& out,
+                                  const ConnectionState& connection_state);
+
+  struct TimerClosure;
+
   // A poll worker which schedules itself unless kicked
   class IOCPWorkClosure : public EventEngine::Closure {
    public:
@@ -137,25 +244,29 @@ class WindowsEventEngine : public EventEngine,
     IOCP* iocp_;
   };
 
+  // Called via IOCP notifications when a connection is ready to be processed.
+  // Either this or the deadline timer will run, never both.
   void OnConnectCompleted(std::shared_ptr<ConnectionState> state);
 
-  // CancelConnect called from within the deadline timer.
-  // In this case, the connection_state->mu is already locked, and timer
-  // cancellation is not possible.
+  // Called after a timeout when no connection has been established.
+  // Either this or the on-connect callback will run, never both.
+  void OnDeadlineTimerFired(std::shared_ptr<ConnectionState> state);
+
+  // CancelConnect, called from within the deadline timer.
+  // Timer cancellation is not possible.
   bool CancelConnectFromDeadlineTimer(ConnectionState* connection_state)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu);
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu());
 
-  // Completes the connection cancellation logic after checking handle validity
-  // and optionally cancelling deadline timers.
+  // Completes the connection cancellation logic after checking handle
+  // validity and optionally cancelling deadline timers.
   bool CancelConnectInternalStateLocked(ConnectionState* connection_state)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu);
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(connection_state->mu());
 
-  struct TimerClosure;
   EventEngine::TaskHandle RunAfterInternal(Duration when,
                                            absl::AnyInvocable<void()> cb);
   grpc_core::Mutex task_mu_;
   TaskHandleSet known_handles_ ABSL_GUARDED_BY(task_mu_);
-  grpc_core::Mutex connection_mu_ ABSL_ACQUIRED_AFTER(ConnectionState::mu);
+  grpc_core::Mutex connection_mu_;
   grpc_core::CondVar connection_cv_;
   ConnectionHandleSet known_connection_handles_ ABSL_GUARDED_BY(connection_mu_);
   std::atomic<intptr_t> aba_token_{0};

data/src/core/lib/event_engine/windows/windows_listener.cc

@@ -15,6 +15,8 @@
 
 #ifdef GPR_WINDOWS
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -47,7 +49,7 @@ WindowsEventEngineListener::SinglePortSocketListener::AsyncIOState::
 
 void WindowsEventEngineListener::SinglePortSocketListener::
     OnAcceptCallbackWrapper::Run() {
-  GPR_ASSERT(io_state_ != nullptr);
+  CHECK_NE(io_state_, nullptr);
   grpc_core::ReleasableMutexLock lock(&io_state_->mu);
   if (io_state_->listener_socket->IsShutdown()) {
     GRPC_EVENT_ENGINE_TRACE(
@@ -124,7 +126,7 @@ WindowsEventEngineListener::SinglePortSocketListener::Create(
   }
   auto result = SinglePortSocketListener::PrepareListenerSocket(sock, addr);
   GRPC_RETURN_IF_ERROR(result.status());
-  GPR_ASSERT(result->port >= 0);
+  CHECK_GE(result->port, 0);
   // Using `new` to access non-public constructor
   return absl::WrapUnique(new SinglePortSocketListener(
       listener, AcceptEx, /*win_socket=*/listener->iocp_->Watch(sock),
@@ -190,17 +192,14 @@ void WindowsEventEngineListener::SinglePortSocketListener::
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu) {
             if (do_close_socket) closesocket(io_state_->accept_socket);
             io_state_->accept_socket = INVALID_SOCKET;
-            GPR_ASSERT(GRPC_LOG_IF_ERROR("SinglePortSocketListener::Start",
-                                         StartLocked()));
+            CHECK(GRPC_LOG_IF_ERROR("SinglePortSocketListener::Start",
+                                    StartLocked()));
           };
   const auto& overlapped_result =
       io_state_->listener_socket->read_info()->result();
   if (overlapped_result.wsa_error != 0) {
-    gpr_log(GPR_ERROR, "%s",
-            GRPC_WSA_ERROR(overlapped_result.wsa_error,
-                           "Skipping on_accept due to error")
-                .ToString()
-                .c_str());
+    LOG(ERROR) << GRPC_WSA_ERROR(overlapped_result.wsa_error,
+                                 "Skipping on_accept due to error");
     return close_socket_and_restart();
   }
   SOCKET tmp_listener_socket = io_state_->listener_socket->raw_socket();
@@ -209,8 +208,7 @@ void WindowsEventEngineListener::SinglePortSocketListener::
                  reinterpret_cast<char*>(&tmp_listener_socket),
                  sizeof(tmp_listener_socket));
   if (err != 0) {
-    gpr_log(GPR_ERROR, "%s",
-            GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt").ToString().c_str());
+    LOG(ERROR) << GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt");
     return close_socket_and_restart();
   }
   EventEngine::ResolvedAddress peer_address;
@@ -219,9 +217,7 @@ void WindowsEventEngineListener::SinglePortSocketListener::
                     const_cast<sockaddr*>(peer_address.address()),
                     &peer_name_len);
   if (err != 0) {
-    gpr_log(
-        GPR_ERROR, "%s",
-        GRPC_WSA_ERROR(WSAGetLastError(), "getpeername").ToString().c_str());
+    LOG(ERROR) << GRPC_WSA_ERROR(WSAGetLastError(), "getpeername");
     return close_socket_and_restart();
   }
   peer_address =
@@ -230,8 +226,7 @@ void WindowsEventEngineListener::SinglePortSocketListener::
   std::string peer_name = "unknown";
   if (!addr_uri.ok()) {
     // TODO(hork): test an early exit/restart here with end2end tests
-    gpr_log(GPR_ERROR, "invalid peer name: %s",
-            addr_uri.status().ToString().c_str());
+    LOG(ERROR) << "invalid peer name: " << addr_uri.status();
   } else {
     peer_name = *addr_uri;
   }
@@ -265,14 +260,10 @@ absl::StatusOr<WindowsEventEngineListener::SinglePortSocketListener::
 WindowsEventEngineListener::SinglePortSocketListener::PrepareListenerSocket(
     SOCKET sock, const EventEngine::ResolvedAddress& addr) {
   auto fail = [&](absl::Status error) -> absl::Status {
-    GPR_ASSERT(!error.ok());
-    auto addr_uri = ResolvedAddressToURI(addr);
+    CHECK(!error.ok());
     error = grpc_error_set_int(
-        grpc_error_set_str(
-            GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket",
-                                          &error, 1),
-            grpc_core::StatusStrProperty::kTargetAddress,
-            addr_uri.ok() ? *addr_uri : addr_uri.status().ToString()),
+        GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket", &error,
+                                      1),
         grpc_core::StatusIntProperty::kFd, static_cast<intptr_t>(sock));
     if (sock != INVALID_SOCKET) closesocket(sock);
     return error;
@@ -374,7 +365,7 @@ absl::StatusOr<int> WindowsEventEngineListener::Bind(
 }
 
 absl::Status WindowsEventEngineListener::Start() {
-  GPR_ASSERT(!started_.exchange(true));
+  CHECK(!started_.exchange(true));
   grpc_core::MutexLock lock(&port_listeners_mu_);
   for (auto& port_listener : port_listeners_) {
     GRPC_RETURN_IF_ERROR(port_listener->Start());
@@ -401,11 +392,10 @@ WindowsEventEngineListener::AddSinglePortSocketListener(
   grpc_core::MutexLock lock(&port_listeners_mu_);
   port_listeners_.emplace_back(std::move(*single_port_listener));
   if (started_.load()) {
-    gpr_log(GPR_ERROR,
-            "WindowsEventEngineListener::%p Bind was called concurrently while "
-            "the Listener was starting. This is invalid usage, all ports must "
-            "be bound before the Listener is started.",
-            this);
+    LOG(ERROR) << "WindowsEventEngineListener::" << this
+               << " Bind was called concurrently while the Listener was "
+                  "starting. This is invalid usage, all ports must be bound "
+                  "before the Listener is started.";
     GRPC_RETURN_IF_ERROR(single_port_listener_ptr->Start());
   }
   return single_port_listener_ptr;

data/src/core/lib/event_engine/work_queue/basic_work_queue.cc

@@ -11,12 +11,12 @@
 // 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.
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
 
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/gprpp/sync.h"
 

data/src/core/lib/event_engine/work_queue/basic_work_queue.h

@@ -13,8 +13,6 @@
 // limitations under the License.
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_BASIC_WORK_QUEUE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_BASIC_WORK_QUEUE_H
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <deque>
@@ -23,6 +21,7 @@
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/work_queue/work_queue.h"
 #include "src/core/lib/gprpp/sync.h"

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

@@ -14,13 +14,12 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_WORK_QUEUE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_WORK_QUEUE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/experiments/config.cc

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/experiments/config.h"
 
 #include <string.h>
@@ -25,12 +23,15 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -147,7 +148,7 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
          j++) {
       // Require that we can check dependent requirements with a linear sweep
       // (implies the experiments generator must DAG sort the experiments)
-      GPR_ASSERT(g_experiment_metadata[i].required_experiments[j] < i);
+      CHECK(g_experiment_metadata[i].required_experiments[j] < i);
       if (!experiments
                .enabled[g_experiment_metadata[i].required_experiments[j]]) {
         experiments.enabled[i] = false;
@@ -227,29 +228,30 @@ void PrintExperimentsList() {
   }
   if (experiment_status.empty()) {
     if (!defaulted_on_experiments.empty()) {
-      gpr_log(GPR_INFO, "gRPC experiments enabled: %s",
-              absl::StrJoin(defaulted_on_experiments, ", ").c_str());
+      VLOG(2) << "gRPC experiments enabled: "
+              << absl::StrJoin(defaulted_on_experiments, ", ");
     }
   } else {
     if (defaulted_on_experiments.empty()) {
-      gpr_log(GPR_INFO, "gRPC experiments: %s",
-              absl::StrJoin(experiment_status, ", ", absl::PairFormatter(":"))
-                  .c_str());
+      VLOG(2) << "gRPC experiments: "
+              << absl::StrJoin(experiment_status, ", ",
+                               absl::PairFormatter(":"));
     } else {
-      gpr_log(GPR_INFO, "gRPC experiments: %s; default-enabled: %s",
-              absl::StrJoin(experiment_status, ", ", absl::PairFormatter(":"))
-                  .c_str(),
-              absl::StrJoin(defaulted_on_experiments, ", ").c_str());
+      VLOG(2) << "gRPC experiments: "
+              << absl::StrJoin(experiment_status, ", ",
+                               absl::PairFormatter(":"))
+              << "; default-enabled: "
+              << absl::StrJoin(defaulted_on_experiments, ", ");
     }
   }
 }
 
 void ForceEnableExperiment(absl::string_view experiment, bool enable) {
-  GPR_ASSERT(Loaded()->load(std::memory_order_relaxed) == false);
+  CHECK(Loaded()->load(std::memory_order_relaxed) == false);
   for (size_t i = 0; i < kNumExperiments; i++) {
     if (g_experiment_metadata[i].name != experiment) continue;
     if (ForcedExperiments()[i].forced) {
-      GPR_ASSERT(ForcedExperiments()[i].value == enable);
+      CHECK(ForcedExperiments()[i].value == enable);
     } else {
       ForcedExperiments()[i].forced = true;
       ForcedExperiments()[i].value = enable;

data/src/core/lib/experiments/config.h

@@ -15,14 +15,14 @@
 #ifndef GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
 #define GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 // #define GRPC_EXPERIMENTS_ARE_FINAL
 
 namespace grpc_core {