grpc 1.60.0 → 1.62.0

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

@@ -0,0 +1,429 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/for_each.h"
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/party.h"
+#include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/promise/prioritized_race.h"
+#include "src/core/lib/promise/status_flag.h"
+#include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/transport/message.h"
+#include "src/core/lib/transport/metadata.h"
+
+namespace grpc_core {
+
+// The common middle part of a call - a reference is held by each of
+// CallInitiator and CallHandler - which provide interfaces that are appropriate
+// for each side of a call.
+// The spine will ultimately host the pipes, filters, and context for one part
+// of a call: ie top-half client channel, sub channel call, server call.
+// TODO(ctiller): eventually drop this when we don't need to reference into
+// legacy promise calls anymore
+class CallSpineInterface {
+ public:
+  virtual ~CallSpineInterface() = default;
+  virtual Pipe<ClientMetadataHandle>& client_initial_metadata() = 0;
+  virtual Pipe<ServerMetadataHandle>& server_initial_metadata() = 0;
+  virtual Pipe<MessageHandle>& client_to_server_messages() = 0;
+  virtual Pipe<MessageHandle>& server_to_client_messages() = 0;
+  virtual Pipe<ServerMetadataHandle>& server_trailing_metadata() = 0;
+  virtual Latch<ServerMetadataHandle>& cancel_latch() = 0;
+  // Add a callback to be called when server trailing metadata is received.
+  void OnDone(absl::AnyInvocable<void()> fn) {
+    if (on_done_ == nullptr) {
+      on_done_ = std::move(fn);
+      return;
+    }
+    on_done_ = [first = std::move(fn), next = std::move(on_done_)]() mutable {
+      first();
+      next();
+    };
+  }
+  void CallOnDone() {
+    if (on_done_ != nullptr) std::exchange(on_done_, nullptr)();
+  }
+  virtual Party& party() = 0;
+  virtual void IncrementRefCount() = 0;
+  virtual void Unref() = 0;
+
+  // Cancel the call with the given metadata.
+  // Regarding the `MUST_USE_RESULT absl::nullopt_t`:
+  // Most cancellation calls right now happen in pipe interceptors;
+  // there `nullopt` indicates terminate processing of this pipe and close with
+  // error.
+  // It's convenient then to have the Cancel operation (setting the latch to
+  // terminate the call) be the last thing that occurs in a pipe interceptor,
+  // and this construction supports that (and has helped the author not write
+  // some bugs).
+  GRPC_MUST_USE_RESULT absl::nullopt_t Cancel(ServerMetadataHandle metadata) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &party());
+    auto& c = cancel_latch();
+    if (c.is_set()) return absl::nullopt;
+    c.Set(std::move(metadata));
+    CallOnDone();
+    client_initial_metadata().sender.CloseWithError();
+    server_initial_metadata().sender.CloseWithError();
+    client_to_server_messages().sender.CloseWithError();
+    server_to_client_messages().sender.CloseWithError();
+    server_trailing_metadata().sender.CloseWithError();
+    return absl::nullopt;
+  }
+
+  auto WaitForCancel() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &party());
+    return cancel_latch().Wait();
+  }
+
+  // Wrap a promise so that if it returns failure it automatically cancels
+  // the rest of the call.
+  // The resulting (returned) promise will resolve to Empty.
+  template <typename Promise>
+  auto CancelIfFails(Promise promise) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &party());
+    using P = promise_detail::PromiseLike<Promise>;
+    using ResultType = typename P::Result;
+    return Map(std::move(promise), [this](ResultType r) {
+      if (!IsStatusOk(r)) {
+        std::ignore = Cancel(StatusCast<ServerMetadataHandle>(r));
+      }
+      return r;
+    });
+  }
+
+  // Spawn a promise that returns Empty{} and save some boilerplate handling
+  // that detail.
+  template <typename PromiseFactory>
+  void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
+    party().Spawn(name, std::move(promise_factory), [](Empty) {});
+  }
+
+  // Spawn a promise that returns some status-like type; if the status
+  // represents failure automatically cancel the rest of the call.
+  template <typename PromiseFactory>
+  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
+    using FactoryType =
+        promise_detail::OncePromiseFactory<void, PromiseFactory>;
+    using PromiseType = typename FactoryType::Promise;
+    using ResultType = typename PromiseType::Result;
+    static_assert(
+        std::is_same<bool,
+                     decltype(IsStatusOk(std::declval<ResultType>()))>::value,
+        "SpawnGuarded promise must return a status-like object");
+    party().Spawn(name, std::move(promise_factory), [this](ResultType r) {
+      if (!IsStatusOk(r)) {
+        if (grpc_trace_promise_primitives.enabled()) {
+          gpr_log(GPR_DEBUG, "SpawnGuarded sees failure: %s",
+                  r.ToString().c_str());
+        }
+        std::ignore = Cancel(StatusCast<ServerMetadataHandle>(std::move(r)));
+      }
+    });
+  }
+
+ private:
+  absl::AnyInvocable<void()> on_done_{nullptr};
+};
+
+class CallSpine final : public CallSpineInterface, public Party {
+ public:
+  static RefCountedPtr<CallSpine> Create(
+      grpc_event_engine::experimental::EventEngine* event_engine,
+      Arena* arena) {
+    return RefCountedPtr<CallSpine>(arena->New<CallSpine>(event_engine, arena));
+  }
+
+  Pipe<ClientMetadataHandle>& client_initial_metadata() override {
+    return client_initial_metadata_;
+  }
+  Pipe<ServerMetadataHandle>& server_initial_metadata() override {
+    return server_initial_metadata_;
+  }
+  Pipe<MessageHandle>& client_to_server_messages() override {
+    return client_to_server_messages_;
+  }
+  Pipe<MessageHandle>& server_to_client_messages() override {
+    return server_to_client_messages_;
+  }
+  Pipe<ServerMetadataHandle>& server_trailing_metadata() override {
+    return server_trailing_metadata_;
+  }
+  Latch<ServerMetadataHandle>& cancel_latch() override { return cancel_latch_; }
+  Party& party() override { return *this; }
+  void IncrementRefCount() override { Party::IncrementRefCount(); }
+  void Unref() override { Party::Unref(); }
+
+ private:
+  friend class Arena;
+  CallSpine(grpc_event_engine::experimental::EventEngine* event_engine,
+            Arena* arena)
+      : Party(arena, 1), event_engine_(event_engine) {}
+
+  class ScopedContext : public ScopedActivity,
+                        public promise_detail::Context<Arena> {
+   public:
+    explicit ScopedContext(CallSpine* spine)
+        : ScopedActivity(&spine->party()), Context<Arena>(spine->arena()) {}
+  };
+
+  bool RunParty() override {
+    ScopedContext context(this);
+    return Party::RunParty();
+  }
+
+  void PartyOver() override {
+    Arena* a = arena();
+    {
+      ScopedContext context(this);
+      CancelRemainingParticipants();
+      a->DestroyManagedNewObjects();
+    }
+    this->~CallSpine();
+    a->Destroy();
+  }
+
+  grpc_event_engine::experimental::EventEngine* event_engine() const override {
+    return event_engine_;
+  }
+
+  // Initial metadata from client to server
+  Pipe<ClientMetadataHandle> client_initial_metadata_{arena()};
+  // Initial metadata from server to client
+  Pipe<ServerMetadataHandle> server_initial_metadata_{arena()};
+  // Messages travelling from the application to the transport.
+  Pipe<MessageHandle> client_to_server_messages_{arena()};
+  // Messages travelling from the transport to the application.
+  Pipe<MessageHandle> server_to_client_messages_{arena()};
+  // Trailing metadata from server to client
+  Pipe<ServerMetadataHandle> server_trailing_metadata_{arena()};
+  // Latch that can be set to terminate the call
+  Latch<ServerMetadataHandle> cancel_latch_;
+  // Event engine associated with this call
+  grpc_event_engine::experimental::EventEngine* const event_engine_;
+};
+
+class CallInitiator {
+ public:
+  explicit CallInitiator(RefCountedPtr<CallSpineInterface> spine)
+      : spine_(std::move(spine)) {}
+
+  auto PushClientInitialMetadata(ClientMetadataHandle md) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return Map(spine_->client_initial_metadata().sender.Push(std::move(md)),
+               [](bool ok) { return StatusFlag(ok); });
+  }
+
+  auto PullServerInitialMetadata() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return Map(spine_->server_initial_metadata().receiver.Next(),
+               [](NextResult<ServerMetadataHandle> md)
+                   -> ValueOrFailure<absl::optional<ServerMetadataHandle>> {
+                 if (!md.has_value()) {
+                   if (md.cancelled()) return Failure{};
+                   return absl::optional<ServerMetadataHandle>();
+                 }
+                 return absl::optional<ServerMetadataHandle>(std::move(*md));
+               });
+  }
+
+  auto PullServerTrailingMetadata() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return PrioritizedRace(
+        Seq(spine_->server_trailing_metadata().receiver.Next(),
+            [spine = spine_](NextResult<ServerMetadataHandle> md) mutable {
+              return [md = std::move(md),
+                      spine]() mutable -> Poll<ServerMetadataHandle> {
+                // If the pipe was closed at cancellation time, we'll see no
+                // value here. Return pending and allow the cancellation to win
+                // the race.
+                if (!md.has_value()) return Pending{};
+                spine->server_trailing_metadata().sender.Close();
+                return std::move(*md);
+              };
+            }),
+        Map(spine_->WaitForCancel(),
+            [spine = spine_](ServerMetadataHandle md) -> ServerMetadataHandle {
+              spine->server_trailing_metadata().sender.CloseWithError();
+              return md;
+            }));
+  }
+
+  auto PullMessage() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return spine_->server_to_client_messages().receiver.Next();
+  }
+
+  auto PushMessage(MessageHandle message) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return Map(
+        spine_->client_to_server_messages().sender.Push(std::move(message)),
+        [](bool r) { return StatusFlag(r); });
+  }
+
+  void FinishSends() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    spine_->client_to_server_messages().sender.Close();
+  }
+
+  template <typename Promise>
+  auto CancelIfFails(Promise promise) {
+    return spine_->CancelIfFails(std::move(promise));
+  }
+
+  void Cancel() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    std::ignore =
+        spine_->Cancel(ServerMetadataFromStatus(absl::CancelledError()));
+  }
+
+  template <typename PromiseFactory>
+  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
+    spine_->SpawnGuarded(name, std::move(promise_factory));
+  }
+
+  template <typename PromiseFactory>
+  void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
+    spine_->SpawnInfallible(name, std::move(promise_factory));
+  }
+
+  template <typename PromiseFactory>
+  auto SpawnWaitable(absl::string_view name, PromiseFactory promise_factory) {
+    return spine_->party().SpawnWaitable(name, std::move(promise_factory));
+  }
+
+  Arena* arena() { return spine_->party().arena(); }
+
+ private:
+  RefCountedPtr<CallSpineInterface> spine_;
+};
+
+class CallHandler {
+ public:
+  explicit CallHandler(RefCountedPtr<CallSpineInterface> spine)
+      : spine_(std::move(spine)) {}
+
+  auto PullClientInitialMetadata() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return Map(spine_->client_initial_metadata().receiver.Next(),
+               [](NextResult<ClientMetadataHandle> md)
+                   -> ValueOrFailure<ClientMetadataHandle> {
+                 if (!md.has_value()) return Failure{};
+                 return std::move(*md);
+               });
+  }
+
+  auto PushServerInitialMetadata(absl::optional<ServerMetadataHandle> md) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return If(
+        md.has_value(),
+        [&md, this]() {
+          return Map(
+              spine_->server_initial_metadata().sender.Push(std::move(*md)),
+              [](bool ok) { return StatusFlag(ok); });
+        },
+        [this]() {
+          spine_->server_initial_metadata().sender.Close();
+          return []() -> StatusFlag { return Success{}; };
+        });
+  }
+
+  auto PushServerTrailingMetadata(ServerMetadataHandle md) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    spine_->server_initial_metadata().sender.Close();
+    spine_->server_to_client_messages().sender.Close();
+    spine_->client_to_server_messages().receiver.CloseWithError();
+    spine_->CallOnDone();
+    return Map(spine_->server_trailing_metadata().sender.Push(std::move(md)),
+               [](bool ok) { return StatusFlag(ok); });
+  }
+
+  auto PullMessage() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return spine_->client_to_server_messages().receiver.Next();
+  }
+
+  auto PushMessage(MessageHandle message) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    return Map(
+        spine_->server_to_client_messages().sender.Push(std::move(message)),
+        [](bool ok) { return StatusFlag(ok); });
+  }
+
+  void Cancel(ServerMetadataHandle status) {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == &spine_->party());
+    std::ignore = spine_->Cancel(std::move(status));
+  }
+
+  void OnDone(absl::AnyInvocable<void()> fn) { spine_->OnDone(std::move(fn)); }
+
+  template <typename Promise>
+  auto CancelIfFails(Promise promise) {
+    return spine_->CancelIfFails(std::move(promise));
+  }
+
+  template <typename PromiseFactory>
+  void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
+    spine_->SpawnGuarded(name, std::move(promise_factory));
+  }
+
+  template <typename PromiseFactory>
+  void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
+    spine_->SpawnInfallible(name, std::move(promise_factory));
+  }
+
+  template <typename PromiseFactory>
+  auto SpawnWaitable(absl::string_view name, PromiseFactory promise_factory) {
+    return spine_->party().SpawnWaitable(name, std::move(promise_factory));
+  }
+
+  Arena* arena() { return spine_->party().arena(); }
+
+ private:
+  RefCountedPtr<CallSpineInterface> spine_;
+};
+
+struct CallInitiatorAndHandler {
+  CallInitiator initiator;
+  CallHandler handler;
+};
+
+CallInitiatorAndHandler MakeCall(
+    grpc_event_engine::experimental::EventEngine* event_engine, Arena* arena);
+
+template <typename CallHalf>
+auto OutgoingMessages(CallHalf h) {
+  struct Wrapper {
+    CallHalf h;
+    auto Next() { return h.PullMessage(); }
+  };
+  return Wrapper{std::move(h)};
+}
+
+// Forward a call from `call_handler` to `call_initiator` (with initial metadata
+// `client_initial_metadata`)
+void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
+                 ClientMetadataHandle client_initial_metadata);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H

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

@@ -91,8 +91,9 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
 
 void AsyncConnectivityStateWatcherInterface::Notify(
     grpc_connectivity_state state, const absl::Status& status) {
-  new Notifier(Ref(), state, status,
-               work_serializer_);  // Deletes itself when done.
+  // Deletes itself when done.
+  new Notifier(RefAsSubclass<AsyncConnectivityStateWatcherInterface>(), state,
+               status, work_serializer_);
 }
 
 //

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

@@ -128,6 +128,10 @@ class ConnectivityStateTracker {
   // Not thread safe; access must be serialized with an external lock.
   absl::Status status() const { return status_; }
 
+  // Returns the number of watchers.
+  // Not thread safe; access must be serialized with an external lock.
+  size_t NumWatchers() const { return watchers_.size(); }
+
  private:
   const char* name_;
   std::atomic<grpc_connectivity_state> state_{grpc_connectivity_state()};

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

@@ -227,11 +227,3 @@ void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
 }
 
 }  // namespace grpc_core
-
-void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
-                                grpc_handshaker* handshaker) {
-  // This is a transition method to aid the API change for handshakers.
-  grpc_core::RefCountedPtr<grpc_core::Handshaker> refd_hs(
-      static_cast<grpc_core::Handshaker*>(handshaker));
-  mgr->Add(refd_hs);
-}

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

@@ -162,11 +162,4 @@ class HandshakeManager : public RefCounted<HandshakeManager> {
 
 }  // namespace grpc_core
 
-// TODO(arjunroy): These are transitional to account for the new handshaker API
-// and will eventually be removed entirely.
-typedef grpc_core::HandshakeManager grpc_handshake_manager;
-typedef grpc_core::Handshaker grpc_handshaker;
-void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
-                                grpc_handshaker* handshaker);
-
 #endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_H

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

@@ -0,0 +1,45 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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/transport/message.h"
+
+#include "absl/strings/str_cat.h"
+
+#include <grpc/impl/grpc_types.h>
+
+namespace grpc_core {
+
+std::string Message::DebugString() const {
+  std::string out = absl::StrCat(payload_.Length(), "b");
+  auto flags = flags_;
+  auto explain = [&flags, &out](uint32_t flag, absl::string_view name) {
+    if (flags & flag) {
+      flags &= ~flag;
+      absl::StrAppend(&out, ":", name);
+    }
+  };
+  explain(GRPC_WRITE_BUFFER_HINT, "write_buffer");
+  explain(GRPC_WRITE_NO_COMPRESS, "no_compress");
+  explain(GRPC_WRITE_THROUGH, "write_through");
+  explain(GRPC_WRITE_INTERNAL_COMPRESS, "compress");
+  explain(GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED, "was_compressed");
+  if (flags != 0) {
+    absl::StrAppend(&out, ":huh=0x", absl::Hex(flags));
+  }
+  return out;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,61 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_MESSAGE_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_MESSAGE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice_buffer.h"
+
+/// Internal bit flag for grpc_begin_message's \a flags signaling the use of
+/// compression for the message. (Does not apply for stream compression.)
+#define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
+/// Internal bit flag for determining whether the message was compressed and had
+/// to be decompressed by the message_decompress filter. (Does not apply for
+/// stream compression.)
+#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
+/// Mask of all valid internal flags.
+#define GRPC_WRITE_INTERNAL_USED_MASK \
+  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
+
+namespace grpc_core {
+
+class Message {
+ public:
+  Message() = default;
+  ~Message() = default;
+  Message(SliceBuffer payload, uint32_t flags)
+      : payload_(std::move(payload)), flags_(flags) {}
+  Message(const Message&) = delete;
+  Message& operator=(const Message&) = delete;
+
+  uint32_t flags() const { return flags_; }
+  uint32_t& mutable_flags() { return flags_; }
+  SliceBuffer* payload() { return &payload_; }
+  const SliceBuffer* payload() const { return &payload_; }
+
+  std::string DebugString() const;
+
+ private:
+  SliceBuffer payload_;
+  uint32_t flags_ = 0;
+};
+
+using MessageHandle = Arena::PoolPtr<Message>;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_MESSAGE_H

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

@@ -0,0 +1,37 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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/transport/metadata.h"
+
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_core {
+
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status,
+                                              Arena* arena) {
+  auto hdl = arena->MakePooled<ServerMetadata>(arena);
+  grpc_status_code code;
+  std::string message;
+  grpc_error_get_status(status, Timestamp::InfFuture(), &code, &message,
+                        nullptr, nullptr);
+  hdl->Set(GrpcStatusMetadata(), code);
+  if (!status.ok()) {
+    hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(message));
+  }
+  return hdl;
+}
+
+}  // namespace grpc_core