grpc 1.71.0 → 1.72.0

data/src/core/lib/iomgr/tcp_posix.cc

@@ -16,21 +16,15 @@
 //
 //
 
-#include <grpc/impl/grpc_types.h>
 #include <grpc/support/port_platform.h>
 
-#include <optional>
-
-#include "absl/base/thread_annotations.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
 #include <errno.h>
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
@@ -48,12 +42,21 @@
 #include <unistd.h>
 
 #include <algorithm>
+#include <optional>
 #include <unordered_map>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -61,7 +64,6 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
@@ -73,7 +75,6 @@
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
-#include "src/core/util/useful.h"
 
 #ifndef SOL_TCP
 #define SOL_TCP IPPROTO_TCP
@@ -735,13 +736,12 @@ static void finish_estimate(grpc_tcp* tcp) {
   tcp->bytes_read_this_round = 0;
 }
 
-static grpc_error_handle tcp_annotate_error(grpc_error_handle src_error,
-                                            grpc_tcp* tcp) {
-  return grpc_error_set_int(
-      grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kFd, tcp->fd),
-      // All tcp errors are marked with UNAVAILABLE so that application may
-      // choose to retry.
-      grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
+static grpc_error_handle tcp_annotate_error(grpc_error_handle src_error) {
+  return grpc_error_set_int(src_error,
+                            // All tcp errors are marked with UNAVAILABLE so
+                            // that application may choose to retry.
+                            grpc_core::StatusIntProperty::kRpcStatus,
+                            GRPC_STATUS_UNAVAILABLE);
 }
 
 static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error);
@@ -969,12 +969,10 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
       // 0 read size ==> end of stream
       grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);
       if (read_bytes == 0) {
-        *error = tcp_annotate_error(absl::InternalError("Socket closed"), tcp);
+        *error = tcp_annotate_error(absl::InternalError("Socket closed"));
       } else {
-        *error =
-            tcp_annotate_error(absl::InternalError(absl::StrCat(
-                                   "recvmsg:", grpc_core::StrError(errno))),
-                               tcp);
+        *error = tcp_annotate_error(absl::InternalError(
+            absl::StrCat("recvmsg:", grpc_core::StrError(errno))));
       }
       return true;
     }
@@ -1122,8 +1120,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
     tcp_trace_read(tcp, tcp_read_error);
   } else {
     if (!tcp->memory_owner.is_valid() && error.ok()) {
-      tcp_read_error =
-          tcp_annotate_error(absl::InternalError("Socket closed"), tcp);
+      tcp_read_error = tcp_annotate_error(absl::InternalError("Socket closed"));
     } else {
       tcp_read_error = error;
     }
@@ -1617,7 +1614,7 @@ static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
         record->UnwindIfThrottled(unwind_slice_idx, unwind_byte_idx);
         return false;
       } else {
-        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"), tcp);
+        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"));
         tcp_shutdown_buffer_list(tcp);
         return true;
       }
@@ -1727,7 +1724,7 @@ static bool tcp_flush(grpc_tcp* tcp, grpc_error_handle* error) {
         }
         return false;
       } else {
-        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"), tcp);
+        *error = tcp_annotate_error(GRPC_OS_ERROR(saved_errno, "sendmsg"));
         grpc_slice_buffer_reset_and_unref(tcp->outgoing_buffer);
         tcp_shutdown_buffer_list(tcp);
         return true;
@@ -1822,11 +1819,10 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
   DCHECK_EQ(tcp->current_zerocopy_send, nullptr);
 
   if (buf->length == 0) {
-    grpc_core::Closure::Run(
-        DEBUG_LOCATION, cb,
-        grpc_fd_is_shutdown(tcp->em_fd)
-            ? tcp_annotate_error(GRPC_ERROR_CREATE("EOF"), tcp)
-            : absl::OkStatus());
+    grpc_core::Closure::Run(DEBUG_LOCATION, cb,
+                            grpc_fd_is_shutdown(tcp->em_fd)
+                                ? tcp_annotate_error(GRPC_ERROR_CREATE("EOF"))
+                                : absl::OkStatus());
     tcp_shutdown_buffer_list(tcp);
     return;
   }
@@ -1914,9 +1910,40 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
                                             tcp_get_fd,
                                             tcp_can_track_err};
 
+grpc_endpoint* grpc_tcp_create(
+    grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
+    absl::string_view peer_string) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+    // Create an EventEngine endpoint when creating the transport.
+    auto* engine =
+        reinterpret_cast<grpc_event_engine::experimental::EventEngine*>(
+            config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+    if (engine == nullptr) {
+      grpc_core::Crash("EventEngine is not set");
+    }
+    auto* engine_supports_fd = grpc_event_engine::experimental::QueryExtension<
+        grpc_event_engine::experimental::EventEngineSupportsFdExtension>(
+        engine);
+    if (engine_supports_fd == nullptr) {
+      grpc_core::Crash("EventEngine does not support fds");
+    }
+    int wrapped_fd;
+    grpc_fd_orphan(fd, nullptr, &wrapped_fd, "Hand fd over to EventEngine");
+    return grpc_event_engine_endpoint_create(
+        engine_supports_fd->CreateEndpointFromFd(wrapped_fd, config));
+  }
+  return grpc_tcp_create(fd, TcpOptionsFromEndpointConfig(config), peer_string);
+}
+
 grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
                                const grpc_core::PosixTcpOptions& options,
                                absl::string_view peer_string) {
+  CHECK(!grpc_event_engine::experimental::UsePollsetAlternative())
+      << "This function must not be called when the pollset_alternative "
+         "experiment is enabled. This is a bug.";
+  CHECK(!grpc_core::IsEventEngineForAllOtherEndpointsEnabled())
+      << "The event_engine_for_all_other_endpoints experiment should prevent "
+         "this method from being called. This is a bug.";
   grpc_tcp* tcp = new grpc_tcp(options);
   tcp->base.vtable = &vtable;
   tcp->peer_string = std::string(peer_string);

data/src/core/lib/iomgr/tcp_posix.h

@@ -29,6 +29,7 @@
 // otherwise specified.
 //
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -38,12 +39,19 @@
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 
-/// Create a tcp endpoint given a file descriptor and a read slice size.
-/// Takes ownership of \a fd. Takes ownership of the \a slice_allocator.
+/// [DEPRECATED] Create a tcp endpoint given a file descriptor and a read slice
+/// size. Takes ownership of \a fd. This is a legacy API, intended for iomgr use
+/// only, it will not support EventEngine.
 grpc_endpoint* grpc_tcp_create(grpc_fd* fd,
                                const grpc_core::PosixTcpOptions& options,
                                absl::string_view peer_string);
 
+/// Create a tcp endpoint given a file descriptor and a read slice size.
+/// Takes ownership of \a fd.
+grpc_endpoint* grpc_tcp_create(
+    grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
+    absl::string_view peer_string);
+
 /// Return the tcp endpoint's fd, or -1 if this is not available. Does not
 /// release the fd. Requires: \a ep must be a tcp endpoint.
 int grpc_tcp_fd(grpc_endpoint* ep);

data/src/core/lib/iomgr/tcp_server_posix.cc

@@ -16,6 +16,7 @@
 //
 //
 
+#include <grpc/slice_buffer.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
 
@@ -475,6 +476,7 @@ static void on_read(void* arg, grpc_error_handle err) {
     acceptor->port_index = sp->port_index;
     acceptor->fd_index = sp->fd_index;
     acceptor->external_connection = false;
+    acceptor->pending_data = nullptr;
     sp->server->on_accept_cb(
         sp->server->on_accept_cb_arg,
         grpc_tcp_create(fdobj, sp->server->options, addr_uri.value()),
@@ -926,7 +928,13 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
     acceptor->fd_index = -1;
     acceptor->external_connection = true;
     acceptor->listener_fd = listener_fd;
-    acceptor->pending_data = buf;
+    if (buf != nullptr && buf->data.raw.slice_buffer.length > 0) {
+      acceptor->pending_data = grpc_raw_byte_buffer_create(nullptr, 0);
+      grpc_slice_buffer_swap(&acceptor->pending_data->data.raw.slice_buffer,
+                             &buf->data.raw.slice_buffer);
+    } else {
+      acceptor->pending_data = nullptr;
+    }
     s_->on_accept_cb(s_->on_accept_cb_arg,
                      grpc_tcp_create(fdobj, s_->options, addr_uri.value()),
                      read_notifier_pollset, acceptor);

data/src/core/lib/iomgr/tcp_server_utils_posix_common.cc

@@ -273,10 +273,7 @@ error:
   if (fd >= 0) {
     close(fd);
   }
-  grpc_error_handle ret = grpc_error_set_int(
-      GRPC_ERROR_CREATE_REFERENCING("Unable to configure socket", &err, 1),
-      grpc_core::StatusIntProperty::kFd, fd);
-  return ret;
+  return GRPC_ERROR_CREATE_REFERENCING("Unable to configure socket", &err, 1);
 }
 
 #endif  // GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -70,8 +70,6 @@ using ::grpc_event_engine::experimental::MemoryAllocator;
 using ::grpc_event_engine::experimental::MemoryQuotaBasedMemoryAllocatorFactory;
 using ::grpc_event_engine::experimental::ResolvedAddressSetPort;
 using ::grpc_event_engine::experimental::RunEventEngineClosure;
-using ::grpc_event_engine::experimental::WindowsEventEngine;
-using ::grpc_event_engine::experimental::WindowsEventEngineListener;
 }  // namespace
 
 // one listening port
@@ -129,7 +127,7 @@ struct grpc_tcp_server {
   grpc_closure* shutdown_complete;
 
   // used for the EventEngine shim
-  WindowsEventEngineListener* ee_listener;
+  std::unique_ptr<EventEngine::Listener> ee_listener;
 };
 
 // TODO(hork): This may be refactored to share with posix engine and event
@@ -179,6 +177,7 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->shutdown_starting.head = NULL;
   s->shutdown_starting.tail = NULL;
   s->shutdown_complete = shutdown_complete;
+  new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
   *server = s;
   return absl::OkStatus();
 }
@@ -197,6 +196,7 @@ static void destroy_server(void* arg, grpc_error_handle /* error */) {
     unlink_if_unix_domain_socket(&sp->resolved_addr);
     gpr_free(sp);
   }
+  std::destroy_at(&s->ee_listener);
   gpr_mu_destroy(&s->mu);
   gpr_free(s);
 }
@@ -292,9 +292,8 @@ static grpc_error_handle prepare_socket(SOCKET sock,
 
 failure:
   CHECK(!error.ok());
-  error = grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING(
-                                 "Failed to prepare server socket", &error, 1),
-                             grpc_core::StatusIntProperty::kFd, (intptr_t)sock);
+  error = GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket",
+                                        &error, 1);
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -445,6 +444,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
     acceptor->port_index = sp->port_index;
     acceptor->fd_index = 0;
     acceptor->external_connection = false;
+    acceptor->pending_data = nullptr;
     sp->server->on_accept_cb(sp->server->on_accept_cb_arg, ep, NULL, acceptor);
   }
   // As we were notified from the IOCP of one and exactly one accept,
@@ -641,11 +641,8 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
                                              grpc_tcp_server_cb on_accept_cb,
                                              void* on_accept_cb_arg,
                                              grpc_tcp_server** server) {
-  // On Windows, the event_engine_listener experiment only supports the
-  // default engine
-  WindowsEventEngine* engine_ptr = reinterpret_cast<WindowsEventEngine*>(
-      config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
+  new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
   CHECK_NE(on_accept_cb, nullptr);
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
@@ -657,6 +654,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
     acceptor->port_index = -1;
     acceptor->fd_index = -1;
     acceptor->external_connection = false;
+    acceptor->pending_data = nullptr;
     on_accept_cb(on_accept_cb_arg,
                  grpc_event_engine_endpoint_create(std::move(endpoint)),
                  nullptr, acceptor);
@@ -673,11 +671,18 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   }
   gpr_ref_init(&s->refs, 1);
   gpr_mu_init(&s->mu);
-  s->ee_listener = new WindowsEventEngineListener(
-      engine_ptr->poller(), std::move(accept_cb), std::move(on_shutdown),
+  EventEngine* engine = reinterpret_cast<EventEngine*>(
+      config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
+  CHECK_NE(engine, nullptr);
+  auto listener = engine->CreateListener(
+      std::move(accept_cb), std::move(on_shutdown), config,
       std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
-          resource_quota->memory_quota()),
-      engine_ptr->shared_from_this(), engine_ptr->thread_pool(), config);
+          resource_quota->memory_quota()));
+  GRPC_RETURN_IF_ERROR(listener.status());
+  CHECK_NE(listener->get(), nullptr);
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::" << engine << ": created Listener::" << listener->get();
+  s->ee_listener = std::move(*listener);
   s->active_ports = -1;
   s->on_accept_cb = [](void* /* arg */, grpc_endpoint* /* ep */,
                        grpc_pollset* /* accepting_pollset */,
@@ -733,7 +738,13 @@ static grpc_tcp_server* event_engine_ref(grpc_tcp_server* s) {
 }
 
 static void event_engine_shutdown_listeners(grpc_tcp_server* s) {
-  s->ee_listener->ShutdownListeners();
+  auto* iomgr_compatible_listener =
+      grpc_event_engine::experimental::QueryExtension<
+          grpc_event_engine::experimental::IomgrCompatibleListener>(
+          s->ee_listener.get());
+  if (iomgr_compatible_listener != nullptr) {
+    iomgr_compatible_listener->Shutdown();
+  }
 }
 
 static void event_engine_unref(grpc_tcp_server* s) {
@@ -743,7 +754,7 @@ static void event_engine_unref(grpc_tcp_server* s) {
     grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_starting);
     gpr_mu_unlock(&s->mu);
     gpr_mu_destroy(&s->mu);
-    delete s->ee_listener;
+    std::destroy_at(&s->ee_listener);
     gpr_free(s);
   }
 }

data/src/core/lib/iomgr/wakeup_fd_pipe.cc

@@ -43,9 +43,17 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   }
   grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
-  if (!err.ok()) return err;
+  if (!err.ok()) {
+    close(pipefd[0]);
+    close(pipefd[1]);
+    return err;
+  }
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
-  if (!err.ok()) return err;
+  if (!err.ok()) {
+    close(pipefd[0]);
+    close(pipefd[1]);
+    return err;
+  }
   fd_info->read_fd = pipefd[0];
   fd_info->write_fd = pipefd[1];
   return absl::OkStatus();

data/src/core/lib/promise/all_ok.h

@@ -30,6 +30,37 @@
 #include "src/core/lib/promise/status_flag.h"
 
 namespace grpc_core {
+// AllOk promise combinator.
+//
+// Input:
+// 1. Two or more promises.
+// 2. All promises MUST return either a Poll<StatusFlag> or Poll<absl::Status>.
+//
+// Return:
+// 1. The return type of AllOk<Result, Promises...> is Poll<Result>, where
+// Result is either StatusFlag or absl::Status.
+// 2. If Result is StatusFlag, then all the promises MUST return
+// Poll<StatusFlag>.
+// 3. If Result is absl::Status, then the promises may return either
+// Poll<StatusFlag> or Poll<absl::Status>.
+// For further understanding of points 2 and 3, refer the WithMixedTypes* tests
+// in all_ok_test.cc.
+//
+// Polling the AllOk combinator works in the following way :
+// Polling this AllOk combinator will make the pending promises run
+// serially, in order and on the same thread.
+// Each promise being executed either returns a status (StatusFlag or
+// absl::Status) or Pending{}. Each subsequent execution of the AllOk will only
+// execute the input promises which are still pending. This mechanism ensures
+// that no promise is executed after it resolves, which is an essential
+// requirement. If all the promises have finished running successfully, the
+// AllOk combinator will return a success status. If there is at least one
+// promise that has returned Pending{}, the AllOk combinator will return
+// Pending{}.
+//
+// The execution of promises in the AllOk combinator will stop if any one
+// promise returns a failure status. This failure status is returned by the
+// AllOk combinator.
 
 namespace promise_detail {
 

data/src/core/lib/promise/loop.h

@@ -60,14 +60,17 @@ namespace grpc_core {
 // {
 //   std::string execution_order;
 //   int i = 0;
-//   Poll<int> retval = Loop([&execution_order, &i]() -> LoopCtl<int> {
-//     absl::StrAppend(&execution_order, i);
-//     i++;
-//     if (i < 5) return Continue();
-//     return i;
+//   Poll<int> retval = Loop([&execution_order, &i]() {
+//       return [&execution_order, &i]() -> LoopCtl<int> {
+//           absl::StrAppend(&execution_order, i);
+//           i++;
+//           if (i < 5) return Continue();
+//           return i;
+//       };
 //   })();
 //   EXPECT_TRUE(retval.ready());
 //   EXPECT_EQ(retval.value(), 5);
+//   EXPECT_EQ(i, 5);
 //   EXPECT_STREQ(execution_order.c_str(), "01234");
 // }
 

data/src/core/lib/promise/map.h

@@ -102,8 +102,34 @@ class FusedFns {
 }  // namespace promise_detail
 
 // Mapping combinator.
-// Takes a promise, and a synchronous function to mutate its result, and
-// returns a promise.
+//
+// Input:
+// 1. The first argument is a promise.
+// 2. The second argument is a synchronous function.
+// 3. The synchronous function MUST be callable with the result type of the
+// promise.
+// 4. If the promise returns void, the synchronous function MUST be callable
+// with Empty.
+//
+// Return:
+// Mapping combinator returns Poll<T> where T is the return type of the
+// synchronous function.
+// Note: If the synchronous function returns void, the result type of the
+// mapping combinator will be Poll<Empty>.
+//
+// Polling the mapping combinator works as follows:
+// 1. Poll the promise.
+// 2. If the promise is pending, return Pending{}.
+// 3. If the promise is ready, return the result of the synchronous function.
+// Note: If the first argument to the Map is a promise factory instead of a
+// promise, Map will pass the promise returned by the promise factory as a
+// parameter to the synchronous function.
+//
+// Example:
+// TEST(MapTest, Works) {
+//   Promise<int> x = Map([]() { return 42; }, [](int i) { return i / 2; });
+//   EXPECT_THAT(x(), IsReady(21));
+// }
 template <typename Promise, typename Fn>
 class Map {
   using PromiseType = promise_detail::PromiseLike<Promise>;
@@ -251,6 +277,43 @@ auto AddErrorPrefix(absl::string_view prefix, Promise promise) {
   });
 }
 
+// Input : A promise that resolves to Type T
+// Returns : A Map promise which contains the input promise and then discards
+// the return value of the input promise. the main use case for DiscardResult is
+// when you need to pass a promise as a parameter, and it returns a status or
+// some value which cannot be discarded. If this value is not used, the compiler
+// gives an error. DiscardResult helps to discard the return value of the
+// promise.
+template <typename Promise>
+auto DiscardResult(Promise promise) {
+  return Map(std::move(promise), [](auto) {});
+}
+
+// Given a promise, and N values, return a tuple with the resolved promise
+// first, and then the N values stapled to it.
+template <typename Promise, typename... Values>
+auto Staple(Promise promise, Values&&... values) {
+  return Map(std::move(promise), [values = std::tuple(std::forward<Values>(
+                                      values)...)](auto first_value) mutable {
+    return std::tuple_cat(std::tuple(std::move(first_value)),
+                          std::move(values));
+  });
+}
+
+// Same as Staple, but assumes a StatusOr<X>, and returns X, Values.
+template <typename Promise, typename... Values>
+auto TryStaple(Promise promise, Values&&... values) {
+  return Map(
+      std::move(promise),
+      [values = std::tuple(std::forward<Values>(values)...)](
+          auto first_value) mutable
+          -> absl::StatusOr<std::tuple<decltype(*first_value), Values...>> {
+        if (!first_value.ok()) return first_value.status();
+        return std::tuple_cat(std::tuple(std::move(*first_value)),
+                              std::move(values));
+      });
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_MAP_H

data/src/core/lib/promise/party.h

@@ -35,6 +35,7 @@
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/util/check_class_size.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/ref_counted.h"
@@ -305,7 +306,8 @@ class Party : public Activity, private Wakeable {
   // The party can poll the promise until it is resolved, or until the party is
   // shut down.
   // The on_complete callback will be called with the result of the
-  // promise if it completes.
+  // promise if it completes. Even if the promise returns a failed status,
+  // on_complete will be called.
   // promise_factory called to create the promise with the party lock taken;
   // after the promise is created the factory is destroyed. This means that
   // pointers or references to factory members will be invalidated after the
@@ -637,6 +639,8 @@ class Party : public Activity, private Wakeable {
   RefCountedPtr<Arena> arena_;
 };
 
+GRPC_CHECK_CLASS_SIZE(Party, 180);
+
 template <>
 struct ContextSubclass<Party> {
   using Base = Activity;

data/src/core/lib/promise/poll.h

@@ -23,6 +23,7 @@
 
 #include "absl/log/check.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 #include "src/core/util/construct_destruct.h"
 
 namespace grpc_core {
@@ -281,39 +282,40 @@ std::string PollToString(
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<T>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const T& value) {
+  absl::Format(&sink, "%v", value);
+}
+
+template <typename Sink, typename... Ts>
+void PollValueStringify(Sink& sink, const std::tuple<Ts...>& values) {
+  absl::Format(&sink, "(%v)", absl::StrJoin(values, ", "));
+}
+
+template <typename Sink, typename T>
+void PollValueStringify(Sink& sink, const std::optional<T>& value) {
+  if (!value.has_value()) {
+    sink.Append("nullopt");
     return;
   }
-  absl::Format(&sink, "%v", poll.value());
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<absl::StatusOr<T>>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const absl::StatusOr<T>& value) {
+  if (!value.ok()) {
+    PollValueStringify(sink, value.status());
     return;
   }
-  if (poll.value().ok()) {
-    absl::Format(&sink, "%v", *poll.value());
-  } else {
-    absl::Format(&sink, "%v", poll.value().status());
-  }
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<std::optional<T>>& poll) {
+void AbslStringify(Sink& sink, const Poll<T>& poll) {
   if (poll.pending()) {
     absl::Format(&sink, "<<pending>>");
     return;
   }
-  const auto& value = poll.value();
-  if (value.has_value()) {
-    absl::Format(&sink, "%v", value);
-  } else {
-    sink.append("nullopt");
-  }
+  PollValueStringify(sink, poll.value());
 }
 
 // Hack to get metadata printing
@@ -326,7 +328,7 @@ void AbslStringify(
   }
   const auto& value = poll.value();
   if (value.has_value()) {
-    absl::Format(&sink, "%v", *value);
+    PollValueStringify(sink, *value);
   } else {
     sink.Append("nullopt");
   }

data/src/core/lib/promise/promise.h

@@ -83,12 +83,12 @@ struct ImmediateOkStatus {
 };
 
 // Typecheck that a promise returns the expected return type.
-// usage: auto promise = WithResult<int>([]() { return 3; });
+// usage: auto promise = AssertResultType<int>([]() { return 3; });
 // NOTE: there are tests in promise_test.cc that are commented out because they
 // should fail to compile. When modifying this code these should be uncommented
 // and their miscompilation verified.
 template <typename T, typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto WithResult(F f) ->
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AssertResultType(F f) ->
     typename std::enable_if<std::is_same<decltype(f()), Poll<T>>::value,
                             F>::type {
   return f;