grpc 1.69.0 → 1.70.1

data/src/core/lib/transport/call_state.h

@@ -110,6 +110,9 @@ class CallState {
   // Return true if server trailing metadata has been pushed *and* that push was
   // a cancellation.
   bool WasCancelledPushed() const;
+  // Resolves after server trailing metadata has been pushed, regardless of
+  // whether the call was cancelled.
+  Poll<Empty> PollServerTrailingMetadataWasPushed();
 
   /////////////////////////////////////////////////////////////////////////////
   // Debug
@@ -242,6 +245,7 @@ class CallState {
   }
   enum class ServerToClientPushState : uint16_t {
     kStart,
+    kPushedMessageWithoutInitialMetadata,
     kPushedServerInitialMetadata,
     kPushedServerInitialMetadataAndPushedMessage,
     kTrailersOnly,
@@ -254,6 +258,8 @@ class CallState {
     switch (state) {
       case ServerToClientPushState::kStart:
         return "Start";
+      case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
+        return "PushedMessageWithoutInitialMetadata";
       case ServerToClientPushState::kPushedServerInitialMetadata:
         return "PushedServerInitialMetadata";
       case ServerToClientPushState::
@@ -347,7 +353,8 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline void CallState::Start() {
     case ServerToClientPullState::kIdle:
     case ServerToClientPullState::kReading:
     case ServerToClientPullState::kProcessingServerToClientMessage:
-      LOG(FATAL) << "Start called twice";
+      LOG(FATAL) << "Start called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_);
     case ServerToClientPullState::kTerminated:
       break;
   }
@@ -357,7 +364,8 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline void
 CallState::BeginPushClientToServerMessage() {
   GRPC_TRACE_LOG(call_state, INFO)
       << "[call_state] BeginPushClientToServerMessage: "
-      << GRPC_DUMP_ARGS(this, client_to_server_push_state_);
+      << GRPC_DUMP_ARGS(this, client_to_server_push_state_,
+                        client_to_server_push_waiter_);
   switch (client_to_server_push_state_) {
     case ClientToServerPushState::kIdle:
       client_to_server_push_state_ = ClientToServerPushState::kPushedMessage;
@@ -365,10 +373,12 @@ CallState::BeginPushClientToServerMessage() {
       break;
     case ClientToServerPushState::kPushedMessage:
     case ClientToServerPushState::kPushedMessageAndHalfClosed:
-      LOG(FATAL) << "PushClientToServerMessage called twice concurrently";
+      LOG(FATAL) << "PushClientToServerMessage called twice concurrently;"
+                 << GRPC_DUMP_ARGS(client_to_server_push_state_);
       break;
     case ClientToServerPushState::kPushedHalfClose:
-      LOG(FATAL) << "PushClientToServerMessage called after half-close";
+      LOG(FATAL) << "PushClientToServerMessage called after half-close; "
+                 << GRPC_DUMP_ARGS(client_to_server_push_state_);
       break;
     case ClientToServerPushState::kFinished:
       break;
@@ -409,7 +419,8 @@ CallState::ClientToServerHalfClose() {
       break;
     case ClientToServerPushState::kPushedHalfClose:
     case ClientToServerPushState::kPushedMessageAndHalfClosed:
-      LOG(FATAL) << "ClientToServerHalfClose called twice";
+      LOG(FATAL) << "ClientToServerHalfClose called twice;"
+                 << GRPC_DUMP_ARGS(client_to_server_push_state_);
       break;
     case ClientToServerPushState::kFinished:
       break;
@@ -430,7 +441,8 @@ CallState::BeginPullClientInitialMetadata() {
     case ClientToServerPullState::kIdle:
     case ClientToServerPullState::kReading:
     case ClientToServerPullState::kProcessingClientToServerMessage:
-      LOG(FATAL) << "BeginPullClientInitialMetadata called twice";
+      LOG(FATAL) << "BeginPullClientInitialMetadata called twice; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kTerminated:
       break;
@@ -444,7 +456,8 @@ CallState::FinishPullClientInitialMetadata() {
       << GRPC_DUMP_ARGS(this, client_to_server_pull_state_);
   switch (client_to_server_pull_state_) {
     case ClientToServerPullState::kBegin:
-      LOG(FATAL) << "FinishPullClientInitialMetadata called before Begin";
+      LOG(FATAL) << "FinishPullClientInitialMetadata called before Begin; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kProcessingClientInitialMetadata:
       client_to_server_pull_state_ = ClientToServerPullState::kIdle;
@@ -453,7 +466,8 @@ CallState::FinishPullClientInitialMetadata() {
     case ClientToServerPullState::kIdle:
     case ClientToServerPullState::kReading:
     case ClientToServerPullState::kProcessingClientToServerMessage:
-      LOG(FATAL) << "Out of order FinishPullClientInitialMetadata";
+      LOG(FATAL) << "Out of order FinishPullClientInitialMetadata"
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kTerminated:
       break;
@@ -478,7 +492,8 @@ CallState::PollPullClientToServerMessageAvailable() {
       break;
     case ClientToServerPullState::kProcessingClientToServerMessage:
       LOG(FATAL) << "PollPullClientToServerMessageAvailable called while "
-                    "processing a message";
+                    "processing a message; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_);
       break;
     case ClientToServerPullState::kTerminated:
       return Failure{};
@@ -529,14 +544,20 @@ CallState::FinishPullClientToServerMessage() {
   switch (client_to_server_pull_state_) {
     case ClientToServerPullState::kBegin:
     case ClientToServerPullState::kProcessingClientInitialMetadata:
-      LOG(FATAL) << "FinishPullClientToServerMessage called before Begin";
+      LOG(FATAL) << "FinishPullClientToServerMessage called before Begin; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPullState::kIdle:
-      LOG(FATAL) << "FinishPullClientToServerMessage called twice";
+      LOG(FATAL) << "FinishPullClientToServerMessage called twice; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPullState::kReading:
       LOG(FATAL) << "FinishPullClientToServerMessage called before "
-                    "PollPullClientToServerMessageAvailable";
+                    "PollPullClientToServerMessageAvailable; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPullState::kProcessingClientToServerMessage:
       client_to_server_pull_state_ = ClientToServerPullState::kIdle;
@@ -552,7 +573,9 @@ CallState::FinishPullClientToServerMessage() {
       break;
     case ClientToServerPushState::kIdle:
     case ClientToServerPushState::kPushedHalfClose:
-      LOG(FATAL) << "FinishPullClientToServerMessage called without a message";
+      LOG(FATAL) << "FinishPullClientToServerMessage called without a message; "
+                 << GRPC_DUMP_ARGS(client_to_server_pull_state_,
+                                   client_to_server_push_state_);
       break;
     case ClientToServerPushState::kPushedMessageAndHalfClosed:
       client_to_server_push_state_ = ClientToServerPushState::kPushedHalfClose;
@@ -573,9 +596,26 @@ CallState::PushServerInitialMetadata() {
       ServerTrailingMetadataState::kNotPushed) {
     return Failure{};
   }
-  CHECK_EQ(server_to_client_push_state_, ServerToClientPushState::kStart);
-  server_to_client_push_state_ =
-      ServerToClientPushState::kPushedServerInitialMetadata;
+  switch (server_to_client_push_state_) {
+    case ServerToClientPushState::kStart:
+      server_to_client_push_state_ =
+          ServerToClientPushState::kPushedServerInitialMetadata;
+      break;
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
+      server_to_client_push_state_ =
+          ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage;
+      break;
+    case ServerToClientPushState::kPushedServerInitialMetadata:
+    case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
+    case ServerToClientPushState::kTrailersOnly:
+    case ServerToClientPushState::kIdle:
+    case ServerToClientPushState::kPushedMessage:
+      LOG(FATAL) << "PushServerInitialMetadata called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_push_state_);
+      break;
+    case ServerToClientPushState::kFinished:
+      break;
+  }
   server_to_client_push_waiter_.Wake();
   return Success{};
 }
@@ -587,16 +627,18 @@ CallState::BeginPushServerToClientMessage() {
       << GRPC_DUMP_ARGS(this, server_to_client_push_state_);
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
-      LOG(FATAL) << "BeginPushServerToClientMessage called before "
-                    "PushServerInitialMetadata";
+      server_to_client_push_state_ =
+          ServerToClientPushState::kPushedMessageWithoutInitialMetadata;
       break;
     case ServerToClientPushState::kPushedServerInitialMetadata:
       server_to_client_push_state_ =
           ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage;
       break;
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedMessage:
-      LOG(FATAL) << "BeginPushServerToClientMessage called twice concurrently";
+      LOG(FATAL) << "BeginPushServerToClientMessage called twice concurrently; "
+                 << GRPC_DUMP_ARGS(server_to_client_push_state_);
       break;
     case ServerToClientPushState::kTrailersOnly:
       // Will fail in poll.
@@ -619,9 +661,11 @@ CallState::PollPushServerToClientMessage() {
     case ServerToClientPushState::kStart:
     case ServerToClientPushState::kPushedServerInitialMetadata:
       LOG(FATAL) << "PollPushServerToClientMessage called before "
-                 << "PushServerInitialMetadata";
+                 << "PushServerInitialMetadata; "
+                 << GRPC_DUMP_ARGS(server_to_client_push_state_);
     case ServerToClientPushState::kTrailersOnly:
       return false;
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedMessage:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
       return server_to_client_push_waiter_.pending();
@@ -640,7 +684,7 @@ CallState::PushServerTrailingMetadata(bool cancel) {
       << GRPC_DUMP_ARGS(this, cancel, server_trailing_metadata_state_,
                         server_to_client_push_state_,
                         client_to_server_push_state_,
-                        server_trailing_metadata_waiter_.DebugString());
+                        server_trailing_metadata_waiter_);
   if (server_trailing_metadata_state_ !=
       ServerTrailingMetadataState::kNotPushed) {
     return false;
@@ -657,6 +701,7 @@ CallState::PushServerTrailingMetadata(bool cancel) {
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
     case ServerToClientPushState::kPushedMessage:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
       if (cancel) {
         server_to_client_push_state_ = ServerToClientPushState::kFinished;
         server_to_client_push_waiter_.Wake();
@@ -717,7 +762,9 @@ CallState::PollPullServerInitialMetadataAvailable() {
     case ServerToClientPullState::kIdle:
     case ServerToClientPullState::kReading:
     case ServerToClientPullState::kProcessingServerToClientMessage:
-      LOG(FATAL) << "PollPullServerInitialMetadataAvailable called twice";
+      LOG(FATAL) << "PollPullServerInitialMetadataAvailable called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kTerminated:
       return false;
   }
@@ -727,6 +774,7 @@ CallState::PollPullServerInitialMetadataAvailable() {
       << server_to_client_pull_state_;
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
       return server_to_client_push_waiter_.pending();
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
@@ -739,7 +787,9 @@ CallState::PollPullServerInitialMetadataAvailable() {
     case ServerToClientPushState::kIdle:
     case ServerToClientPushState::kPushedMessage:
       LOG(FATAL)
-          << "PollPullServerInitialMetadataAvailable after metadata processed";
+          << "PollPullServerInitialMetadataAvailable after metadata processed; "
+          << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                            server_to_client_push_state_);
     case ServerToClientPushState::kFinished:
       server_to_client_pull_state_ = ServerToClientPullState::kTerminated;
       server_to_client_pull_waiter_.Wake();
@@ -775,7 +825,9 @@ CallState::FinishPullServerInitialMetadata() {
     case ServerToClientPullState::kIdle:
     case ServerToClientPullState::kReading:
     case ServerToClientPullState::kProcessingServerToClientMessage:
-      LOG(FATAL) << "Out of order FinishPullServerInitialMetadata";
+      LOG(FATAL) << "Out of order FinishPullServerInitialMetadata; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kTerminated:
       return;
   }
@@ -784,8 +836,11 @@ CallState::FinishPullServerInitialMetadata() {
       << server_to_client_pull_state_;
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
       LOG(FATAL) << "FinishPullServerInitialMetadata called before initial "
-                    "metadata consumed";
+                    "metadata consumed; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kPushedServerInitialMetadata:
       server_to_client_push_state_ = ServerToClientPushState::kIdle;
       server_to_client_push_waiter_.Wake();
@@ -798,7 +853,9 @@ CallState::FinishPullServerInitialMetadata() {
     case ServerToClientPushState::kPushedMessage:
     case ServerToClientPushState::kTrailersOnly:
     case ServerToClientPushState::kFinished:
-      LOG(FATAL) << "FinishPullServerInitialMetadata called twice";
+      LOG(FATAL) << "FinishPullServerInitialMetadata called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
   }
 }
 
@@ -837,13 +894,16 @@ CallState::PollPullServerToClientMessageAvailable() {
       break;
     case ServerToClientPullState::kProcessingServerToClientMessage:
       LOG(FATAL) << "PollPullServerToClientMessageAvailable called while "
-                    "processing a message";
+                    "processing a message; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kTerminated:
       return Failure{};
   }
   DCHECK_EQ(server_to_client_pull_state_, ServerToClientPullState::kReading);
   switch (server_to_client_push_state_) {
     case ServerToClientPushState::kStart:
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
       return server_to_client_push_waiter_.pending();
@@ -907,13 +967,19 @@ CallState::FinishPullServerToClientMessage() {
     case ServerToClientPullState::kStartedReading:
     case ServerToClientPullState::kProcessingServerInitialMetadata:
     case ServerToClientPullState::kProcessingServerInitialMetadataReading:
-      LOG(FATAL)
-          << "FinishPullServerToClientMessage called before metadata available";
+      LOG(FATAL) << "FinishPullServerToClientMessage called before metadata "
+                    "available; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kIdle:
-      LOG(FATAL) << "FinishPullServerToClientMessage called twice";
+      LOG(FATAL) << "FinishPullServerToClientMessage called twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kReading:
       LOG(FATAL) << "FinishPullServerToClientMessage called before "
-                 << "PollPullServerToClientMessageAvailable";
+                 << "PollPullServerToClientMessageAvailable; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPullState::kProcessingServerToClientMessage:
       server_to_client_pull_state_ = ServerToClientPullState::kIdle;
       server_to_client_pull_waiter_.Wake();
@@ -922,20 +988,27 @@ CallState::FinishPullServerToClientMessage() {
       break;
   }
   switch (server_to_client_push_state_) {
+    case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
     case ServerToClientPushState::kPushedServerInitialMetadataAndPushedMessage:
     case ServerToClientPushState::kPushedServerInitialMetadata:
     case ServerToClientPushState::kStart:
       LOG(FATAL) << "FinishPullServerToClientMessage called before initial "
-                    "metadata consumed";
+                    "metadata consumed; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kTrailersOnly:
       LOG(FATAL) << "FinishPullServerToClientMessage called after "
-                    "PushServerTrailingMetadata";
+                    "PushServerTrailingMetadata; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kPushedMessage:
       server_to_client_push_state_ = ServerToClientPushState::kIdle;
       server_to_client_push_waiter_.Wake();
       break;
     case ServerToClientPushState::kIdle:
-      LOG(FATAL) << "FinishPullServerToClientMessage called without a message";
+      LOG(FATAL) << "FinishPullServerToClientMessage called without a message; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_to_client_push_state_);
     case ServerToClientPushState::kFinished:
       break;
   }
@@ -945,10 +1018,9 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline Poll<Empty>
 CallState::PollServerTrailingMetadataAvailable() {
   GRPC_TRACE_LOG(call_state, INFO)
       << "[call_state] PollServerTrailingMetadataAvailable: "
-      << GRPC_DUMP_ARGS(this, server_to_client_pull_state_,
-                        server_to_client_push_state_,
-                        server_trailing_metadata_state_,
-                        server_trailing_metadata_waiter_.DebugString());
+      << GRPC_DUMP_ARGS(
+             this, server_to_client_pull_state_, server_to_client_push_state_,
+             server_trailing_metadata_state_, server_trailing_metadata_waiter_);
   switch (server_to_client_pull_state_) {
     case ServerToClientPullState::kProcessingServerInitialMetadata:
     case ServerToClientPullState::kProcessingServerToClientMessage:
@@ -967,6 +1039,7 @@ CallState::PollServerTrailingMetadataAvailable() {
             break;  // Ready for processing
           }
           ABSL_FALLTHROUGH_INTENDED;
+        case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
         case ServerToClientPushState::kPushedServerInitialMetadata:
         case ServerToClientPushState::
             kPushedServerInitialMetadataAndPushedMessage:
@@ -1001,7 +1074,9 @@ CallState::PollServerTrailingMetadataAvailable() {
     case ServerTrailingMetadataState::kNotPushed:
     case ServerTrailingMetadataState::kPulled:
     case ServerTrailingMetadataState::kPulledCancel:
-      LOG(FATAL) << "PollServerTrailingMetadataAvailable completed twice";
+      LOG(FATAL) << "PollServerTrailingMetadataAvailable completed twice; "
+                 << GRPC_DUMP_ARGS(server_to_client_pull_state_,
+                                   server_trailing_metadata_state_);
   }
   return Empty{};
 }
@@ -1056,6 +1131,24 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool CallState::WasCancelledPushed()
   Crash("Unreachable");
 }
 
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline Poll<Empty>
+CallState::PollServerTrailingMetadataWasPushed() {
+  GRPC_TRACE_LOG(call_state, INFO)
+      << "[call_state] PollWasCancelled: "
+      << GRPC_DUMP_ARGS(this, server_trailing_metadata_state_);
+  switch (server_trailing_metadata_state_) {
+    case ServerTrailingMetadataState::kNotPushed: {
+      return server_trailing_metadata_waiter_.pending();
+    }
+    case ServerTrailingMetadataState::kPushed:
+    case ServerTrailingMetadataState::kPushedCancel:
+    case ServerTrailingMetadataState::kPulled:
+    case ServerTrailingMetadataState::kPulledCancel:
+      return Empty{};
+  }
+  Crash("Unreachable");
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_STATE_H

data/src/core/lib/transport/interception_chain.cc

@@ -18,6 +18,7 @@
 
 #include <cstddef>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/transport/call_destination.h"
 #include "src/core/lib/transport/call_filters.h"
 #include "src/core/lib/transport/call_spine.h"
@@ -44,6 +45,13 @@ CallInitiator HijackedCall::MakeCallWithMetadata(
   return std::move(call.initiator);
 }
 
+CallInitiator Interceptor::MakeChildCall(ClientMetadataHandle metadata,
+                                         RefCountedPtr<Arena> arena) {
+  auto call = MakeCallPair(std::move(metadata), arena);
+  wrapped_destination_->StartCall(std::move(call.handler));
+  return std::move(call.initiator);
+}
+
 namespace {
 class CallStarter final : public UnstartedCallDestination {
  public:

data/src/core/lib/transport/interception_chain.h

@@ -90,6 +90,8 @@ class HijackedCall final {
 
 class Interceptor : public UnstartedCallDestination {
  public:
+  using UnstartedCallDestination::UnstartedCallDestination;
+
   void StartCall(UnstartedCallHandler unstarted_call_handler) final {
     unstarted_call_handler.AddCallStack(filter_stack_);
     InterceptCall(std::move(unstarted_call_handler));
@@ -114,6 +116,13 @@ class Interceptor : public UnstartedCallDestination {
                });
   }
 
+  // Hijack a call with custom initial metadata.
+  // TODO(ctiller): Evaluate whether this or hijack or some other in-between
+  // API is what we need here (I think we need 2 or 3 more fully worked through
+  // samples) and then reduce this surface to one API.
+  CallInitiator MakeChildCall(ClientMetadataHandle metadata,
+                              RefCountedPtr<Arena> arena);
+
   // Consume this call - it will not be passed on to any further filters.
   CallHandler Consume(UnstartedCallHandler unstarted_call_handler) {
     return unstarted_call_handler.StartCall();

data/src/core/load_balancing/endpoint_list.cc

@@ -180,4 +180,14 @@ void EndpointList::ResetBackoffLocked() {
   }
 }
 
+void EndpointList::ReportTransientFailure(absl::Status status) {
+  if (!resolution_note_.empty()) {
+    status = absl::Status(status.code(), absl::StrCat(status.message(), " (",
+                                                      resolution_note_, ")"));
+  }
+  channel_control_helper()->UpdateState(
+      GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+      MakeRefCounted<LoadBalancingPolicy::TransientFailurePicker>(status));
+}
+
 }  // namespace grpc_core

data/src/core/load_balancing/endpoint_list.h

@@ -34,6 +34,7 @@
 #include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/work_serializer.h"
@@ -51,9 +52,9 @@ class MyEndpointList : public EndpointList {
  public:
   MyEndpointList(RefCountedPtr<MyLbPolicy> lb_policy,
                  EndpointAddressesIterator* endpoints,
-                 const ChannelArgs& args,
+                 const ChannelArgs& args, std::string resolution_note,
                  std::vector<std::string>* errors)
-      : EndpointList(std::move(lb_policy),
+      : EndpointList(std::move(lb_policy), std::move(resolution_note),
                      GRPC_TRACE_FLAG_ENABLED(my_tracer)
                          ? "MyEndpointList"
                          : nullptr) {
@@ -132,7 +133,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
     // down-casting in the caller.
     template <typename T>
     T* endpoint_list() const {
-      return static_cast<T*>(endpoint_list_.get());
+      return DownCast<T*>(endpoint_list_.get());
     }
 
     // Templated for convenience, to provide a short-hand for down-casting
@@ -181,12 +182,17 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
 
   void ResetBackoffLocked();
 
+  void ReportTransientFailure(absl::Status status);
+
  protected:
   // We use two-phase initialization here to ensure that the vtable is
   // initialized before we need to use it.  Subclass must invoke Init()
   // from inside its ctor.
-  EndpointList(RefCountedPtr<LoadBalancingPolicy> policy, const char* tracer)
-      : policy_(std::move(policy)), tracer_(tracer) {}
+  EndpointList(RefCountedPtr<LoadBalancingPolicy> policy,
+               std::string resolution_note, const char* tracer)
+      : policy_(std::move(policy)),
+        resolution_note_(std::move(resolution_note)),
+        tracer_(tracer) {}
 
   void Init(EndpointAddressesIterator* endpoints, const ChannelArgs& args,
             absl::FunctionRef<OrphanablePtr<Endpoint>(
@@ -198,7 +204,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
   // in the caller.
   template <typename T>
   T* policy() const {
-    return static_cast<T*>(policy_.get());
+    return DownCast<T*>(policy_.get());
   }
 
   // Returns true if all endpoints have seen their initial connectivity
@@ -214,6 +220,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
       const = 0;
 
   RefCountedPtr<LoadBalancingPolicy> policy_;
+  std::string resolution_note_;
   const char* tracer_;
   std::vector<OrphanablePtr<Endpoint>> endpoints_;
   size_t num_endpoints_seen_initial_state_ = 0;

data/src/core/load_balancing/lb_policy.h

@@ -152,14 +152,6 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// The LB policy may use the existing metadata to influence its routing
     /// decision, and it may add new metadata elements to be sent with the
     /// call to the chosen backend.
-    // TODO(roth): Before making the LB policy API public, consider
-    // whether this is the right way to expose metadata to the picker.
-    // This approach means that if a pick modifies metadata but then we
-    // discard the pick because the subchannel is not connected, the
-    // metadata change will still have been made.  Maybe we actually
-    // want to somehow provide metadata changes in PickResult::Complete
-    // instead?  Or maybe we use a CallTracer that can add metadata when
-    // the call actually starts on the subchannel?
     MetadataInterface* initial_metadata;
     /// An interface for accessing call state.  Can be used to allocate
     /// memory associated with the call in an efficient way.