grpc 1.59.2 → 1.62.0

data/include/grpc/event_engine/event_engine.h

@@ -16,7 +16,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <functional>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
@@ -24,6 +23,7 @@
 #include "absl/status/statusor.h"
 
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/extensible.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/port.h>
 #include <grpc/event_engine/slice_buffer.h>
@@ -79,7 +79,7 @@ namespace experimental {
 ///
 ///
 /// Blocking EventEngine Callbacks
-/// -----------------------------
+/// ------------------------------
 ///
 /// Doing blocking work in EventEngine callbacks is generally not advisable.
 /// While gRPC's default EventEngine implementations have some capacity to scale
@@ -90,8 +90,18 @@ namespace experimental {
 /// *Best Practice* : Occasional blocking work may be fine, but we do not
 /// recommend running a mostly blocking workload in EventEngine threads.
 ///
+///
+/// Thread-safety guarantees
+/// ------------------------
+///
+/// All EventEngine methods are guaranteed to be thread-safe, no external
+/// synchronization is required to call any EventEngine method. Please note that
+/// this does not apply to application callbacks, which may be run concurrently;
+/// application state synchronization must be managed by the application.
+///
 ////////////////////////////////////////////////////////////////////////////////
-class EventEngine : public std::enable_shared_from_this<EventEngine> {
+class EventEngine : public std::enable_shared_from_this<EventEngine>,
+                    public Extensible {
  public:
   /// A duration between two events.
   ///
@@ -167,7 +177,7 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
   /// allocations. gRPC allows applications to set memory constraints per
   /// Channel or Server, and the implementation depends on all dynamic memory
   /// allocation being handled by the quota system.
-  class Endpoint {
+  class Endpoint : public Extensible {
    public:
     /// Shuts down all connections and invokes all pending read or write
     /// callbacks with an error status.
@@ -259,7 +269,7 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
 
   /// Listens for incoming connection requests from gRPC clients and initiates
   /// request processing once connections are established.
-  class Listener {
+  class Listener : public Extensible {
    public:
     /// Called when the listener has accepted a new client connection.
     using AcceptCallback = absl::AnyInvocable<void(
@@ -405,8 +415,8 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
 
   /// Asynchronously executes a task as soon as possible.
   ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. The \a closure will
-  /// not be deleted after it has been run, ownership remains with the caller.
+  /// \a Closures passed to \a Run cannot be cancelled. The \a closure will not
+  /// be deleted after it has been run, ownership remains with the caller.
   ///
   /// Implementations must not execute the closure in the calling thread before
   /// \a Run returns. For example, if the caller must release a lock before the
@@ -415,9 +425,9 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
   virtual void Run(Closure* closure) = 0;
   /// Asynchronously executes a task as soon as possible.
   ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. Unlike the
-  /// overloaded \a Closure alternative, the absl::AnyInvocable version's \a
-  /// closure will be deleted by the EventEngine after the closure has been run.
+  /// \a Closures passed to \a Run cannot be cancelled. Unlike the overloaded \a
+  /// Closure alternative, the absl::AnyInvocable version's \a closure will be
+  /// deleted by the EventEngine after the closure has been run.
   ///
   /// This version of \a Run may be less performant than the \a Closure version
   /// in some scenarios. This overload is useful in situations where performance
@@ -453,13 +463,12 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
                               absl::AnyInvocable<void()> closure) = 0;
   /// Request cancellation of a task.
   ///
-  /// If the associated closure has already been scheduled to run, it will not
-  /// be cancelled, and this function will return false.
+  /// If the associated closure cannot be cancelled for any reason, this
+  /// function will return false.
   ///
-  /// If the associated closure has not been scheduled to run, it will be
-  /// cancelled, and this method will return true. The associated
-  /// absl::AnyInvocable or \a Closure* will not be called. If the closure type
-  /// was an absl::AnyInvocable, it will be destroyed before the method returns.
+  /// If the associated closure can be cancelled, the associated callback will
+  /// never be run, and this method will return true. If the callback type was
+  /// an absl::AnyInvocable, it will be destroyed before the method returns.
   virtual bool Cancel(TaskHandle handle) = 0;
 };
 

data/include/grpc/event_engine/extensible.h

@@ -0,0 +1,68 @@
+// Copyright 2024 The 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_EVENT_ENGINE_EXTENSIBLE_H
+#define GRPC_EVENT_ENGINE_EXTENSIBLE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class Extensible {
+ public:
+  /// A method which allows users to query whether an implementation supports a
+  /// specified extension. The name of the extension is provided as an input.
+  ///
+  /// An extension could be any type with a unique string id. Each extension may
+  /// support additional capabilities and if the implementation supports the
+  /// queried extension, it should return a valid pointer to the extension type.
+  ///
+  /// E.g., use case of an EventEngine::Endpoint supporting a custom extension.
+  ///
+  /// class CustomEndpointExtension {
+  ///  public:
+  ///   static std::string EndpointExtensionName() {
+  ///     return "my.namespace.extension_name";
+  ///   }
+  ///   virtual void Process() = 0;
+  /// }
+  ///
+  /// class CustomEndpoint :
+  ///        public EventEngine::Endpoint, public CustomEndpointExtension {
+  ///   public:
+  ///     void* QueryExtension(absl::string_view id) override {
+  ///       if (id == CustomEndpointExtension::EndpointExtensionName()) {
+  ///         return static_cast<CustomEndpointExtension*>(this);
+  ///       }
+  ///       return nullptr;
+  ///     }
+  ///     void Process() override { ... }
+  ///     ...
+  /// }
+  ///
+  /// auto endpoint =
+  ///     static_cast<CustomEndpointExtension*>(endpoint->QueryExtension(
+  ///         CustomEndpointExtension::EndpointExtensionName()));
+  /// if (endpoint != nullptr) endpoint->Process();
+  ///
+  virtual void* QueryExtension(absl::string_view /*id*/) { return nullptr; }
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_EXTENSIBLE_H

data/include/grpc/event_engine/internal/memory_allocator_impl.h

@@ -50,6 +50,12 @@ class MemoryAllocatorImpl
   /// request.max() inclusively.
   virtual size_t Reserve(MemoryRequest request) = 0;
 
+  /// Allocate a slice, using MemoryRequest to size the number of returned
+  /// bytes. For a variable length request, check the returned slice length to
+  /// verify how much memory was allocated. Takes care of reserving memory for
+  /// any relevant control structures also.
+  virtual grpc_slice MakeSlice(MemoryRequest request) = 0;
+
   /// Release some bytes that were previously reserved.
   /// If more bytes are released than were reserved, we will have undefined
   /// behavior.

data/include/grpc/event_engine/internal/slice_cast.h

@@ -60,6 +60,18 @@ Result& SliceCast(T& value, SliceCastable<Result, T> = {}) {
   return reinterpret_cast<Result&>(value);
 }
 
+// Cast to `Result&&` from `T&&` without any runtime checks.
+// This is only valid if `sizeof(Result) == sizeof(T)`, and if `Result`, `T` are
+// opted in as compatible via `SliceCastable`.
+template <typename Result, typename T>
+Result&& SliceCast(T&& value, SliceCastable<Result, T> = {}) {
+  // Insist upon sizes being equal to catch mismatches.
+  // We assume if sizes are opted in and sizes are equal then yes, these two
+  // types are expected to be layout compatible and actually appear to be.
+  static_assert(sizeof(Result) == sizeof(T), "size mismatch");
+  return reinterpret_cast<Result&&>(value);
+}
+
 }  // namespace internal
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/include/grpc/event_engine/memory_allocator.h

@@ -134,7 +134,9 @@ class MemoryAllocator {
   /// bytes. For a variable length request, check the returned slice length to
   /// verify how much memory was allocated. Takes care of reserving memory for
   /// any relevant control structures also.
-  grpc_slice MakeSlice(MemoryRequest request);
+  grpc_slice MakeSlice(MemoryRequest request) {
+    return allocator_->MakeSlice(request);
+  }
 
   /// A C++ allocator for containers of T.
   template <typename T>

data/include/grpc/event_engine/slice.h

@@ -169,6 +169,11 @@ struct CopyConstructors {
     return Out(grpc_slice_from_copied_buffer(p, len));
   }
 
+  static Out FromCopiedBuffer(const uint8_t* p, size_t len) {
+    return Out(
+        grpc_slice_from_copied_buffer(reinterpret_cast<const char*>(p), len));
+  }
+
   template <typename Buffer>
   static Out FromCopiedBuffer(const Buffer& buffer) {
     return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()),

data/include/grpc/grpc_crl_provider.h

@@ -0,0 +1,94 @@
+//
+//
+// Copyright 2023 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_GRPC_CRL_PROVIDER_H
+#define GRPC_GRPC_CRL_PROVIDER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/grpc_security.h>
+
+namespace grpc_core {
+namespace experimental {
+
+// Opaque representation of a CRL. Must be thread safe.
+class Crl {
+ public:
+  static absl::StatusOr<std::unique_ptr<Crl>> Parse(
+      absl::string_view crl_string);
+  virtual ~Crl() = default;
+  virtual absl::string_view Issuer() = 0;
+};
+
+// Information about a certificate to be used to fetch its associated CRL. Must
+// be thread safe.
+class CertificateInfo {
+ public:
+  virtual ~CertificateInfo() = default;
+  virtual absl::string_view Issuer() const = 0;
+};
+
+// The base class for CRL Provider implementations.
+// CrlProviders can be passed in as a way to supply CRLs during handshakes.
+// CrlProviders must be thread safe. They are on the critical path of gRPC
+// creating a connection and doing a handshake, so the implementation of
+// `GetCrl` should be very fast. It is suggested to have an in-memory map of
+// CRLs for quick lookup and return, and doing expensive updates to this map
+// asynchronously.
+class CrlProvider {
+ public:
+  virtual ~CrlProvider() = default;
+  // Get the CRL associated with a certificate. Read-only.
+  virtual std::shared_ptr<Crl> GetCrl(
+      const CertificateInfo& certificate_info) = 0;
+};
+
+absl::StatusOr<std::shared_ptr<CrlProvider>> CreateStaticCrlProvider(
+    absl::Span<const std::string> crls);
+
+// Creates a CRL Provider that periodically and asynchronously reloads a
+// directory. The refresh_duration minimum is 60 seconds. The
+// reload_error_callback provides a way for the user to specifically log or
+// otherwise notify of errors during reloading. Since reloading is asynchronous
+// and not on the main codepath, the grpc process will continue to run through
+// reloading errors, so this mechanism is an important way to provide signals to
+// your monitoring and alerting setup.
+absl::StatusOr<std::shared_ptr<CrlProvider>> CreateDirectoryReloaderCrlProvider(
+    absl::string_view directory, std::chrono::seconds refresh_duration,
+    std::function<void(absl::Status)> reload_error_callback);
+
+}  // namespace experimental
+}  // namespace grpc_core
+
+// TODO(gtcooke94) - Mark with api macro when all wrapped langauges support C++
+// in core APIs
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the crl provider in the options.
+ */
+void grpc_tls_credentials_options_set_crl_provider(
+    grpc_tls_credentials_options* options,
+    std::shared_ptr<grpc_core::experimental::CrlProvider> provider);
+#endif /* GRPC_GRPC_CRL_PROVIDER_H */

data/include/grpc/grpc_security.h

@@ -815,6 +815,40 @@ GRPCAPI void grpc_tls_certificate_provider_release(
  */
 GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void);
 
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the minimum TLS version that will be negotiated during the TLS
+ * handshake. If not set, the underlying SSL library will set it to TLS v1.2.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_min_tls_version(
+    grpc_tls_credentials_options* options, grpc_tls_version min_tls_version);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the maximum TLS version that will be negotiated during the TLS
+ * handshake. If not set, the underlying SSL library will set it to TLS v1.3.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_max_tls_version(
+    grpc_tls_credentials_options* options, grpc_tls_version max_tls_version);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Copies a grpc_tls_credentials_options.
+ */
+GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_copy(
+    grpc_tls_credentials_options* options);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Destroys a grpc_tls_credentials_options.
+ */
+GRPCAPI void grpc_tls_credentials_options_destroy(
+    grpc_tls_credentials_options* options);
+
 /**
  * EXPERIMENTAL API - Subject to change
  *
@@ -878,7 +912,10 @@ GRPCAPI void grpc_tls_credentials_options_set_identity_cert_name(
 GRPCAPI void grpc_tls_credentials_options_set_cert_request_type(
     grpc_tls_credentials_options* options,
     grpc_ssl_client_certificate_request_type type);
-/**
+
+/** Deprecated in favor of grpc_tls_credentials_options_set_crl_provider. The
+ * crl provider interface provides a significantly more flexible approach to
+ * using CRLs. See gRFC A69 for details.
  * EXPERIMENTAL API - Subject to change
  *
  * If set, gRPC will read all hashed x.509 CRL files in the directory and

data/include/grpc/impl/call.h

@@ -0,0 +1,29 @@
+// Copyright 2023 The 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_IMPL_CALL_H
+#define GRPC_IMPL_CALL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/grpc.h>
+
+// Run a callback in the call's EventEngine.
+// Internal-only
+void grpc_call_run_in_event_engine(const grpc_call* call,
+                                   absl::AnyInvocable<void()> cb);
+
+#endif /* GRPC_IMPL_CALL_H */

data/include/grpc/impl/channel_arg_names.h

@@ -15,7 +15,7 @@
 #ifndef GRPC_IMPL_CHANNEL_ARG_NAMES_H
 #define GRPC_IMPL_CHANNEL_ARG_NAMES_H
 
-// IWYU pragma: private, include "third_party/grpc/include/grpc/grpc.h"
+// IWYU pragma: private, include <grpc/grpc.h>
 // IWYU pragma: friend "src/.*"
 // IWYU pragma: friend "test/.*"
 
@@ -106,6 +106,12 @@
  */
 #define GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS \
   "grpc.http2.min_ping_interval_without_data_ms"
+/** Maximum time to allow a request to be:
+    (1) received by the server, but
+    (2) not requested by a RequestCall (in the completion queue based API)
+    before the request is cancelled */
+#define GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS \
+  "grpc.server_max_unrequested_time_in_server"
 /** Channel arg to override the http2 :scheme header */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a
@@ -328,6 +334,16 @@
 /** Channel arg to set http proxy per channel. If set, the channel arg
  *  value will be preferred over the environment variable settings. */
 #define GRPC_ARG_HTTP_PROXY "grpc.http_proxy"
+/** Specifies an HTTP proxy to use for individual addresses.
+ *  The proxy must be specified as an IP address, not a DNS name.
+ *  If set, the channel arg value will be preferred over the environment
+ *  variable settings. */
+#define GRPC_ARG_ADDRESS_HTTP_PROXY "grpc.address_http_proxy"
+/** Comma separated list of addresses or address ranges that are behind the
+ *  address HTTP proxy.
+ */
+#define GRPC_ARG_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES \
+  "grpc.address_http_proxy_enabled_addresses"
 /** If set to non zero, surfaces the user agent string to the server. User
     agent is surfaced by default. */
 #define GRPC_ARG_SURFACE_USER_AGENT "grpc.surface_user_agent"
@@ -370,6 +386,15 @@
 /** Configure the Differentiated Services Code Point used on outgoing packets.
  *  Integer value ranging from 0 to 63. */
 #define GRPC_ARG_DSCP "grpc.dscp"
+/** Connection Attempt Delay for use in Happy Eyeballs, in milliseconds.
+ *  Defaults to 250ms. */
+#define GRPC_ARG_HAPPY_EYEBALLS_CONNECTION_ATTEMPT_DELAY_MS \
+  "grpc.happy_eyeballs_connection_attempt_delay_ms"
+/** It accepts a MemoryAllocatorFactory as input and If specified, it forces
+ * the default event engine to use memory allocators created using the provided
+ * factory. */
+#define GRPC_ARG_EVENT_ENGINE_USE_MEMORY_ALLOCATOR_FACTORY \
+  "grpc.event_engine_use_memory_allocator_factory"
 /** \} */
 
 #endif /* GRPC_IMPL_CHANNEL_ARG_NAMES_H */

data/include/grpc/impl/slice_type.h

@@ -74,7 +74,7 @@ struct grpc_slice {
   } data;
 };
 
-#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 8
+#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 6
 
 /** Represents an expandable array of slices, to be interpreted as a
    single item. */

data/include/grpc/module.modulemap

@@ -9,9 +9,11 @@ header "byte_buffer.h"
   header "fork.h"
   header "grpc.h"
   header "grpc_audit_logging.h"
+  header "grpc_crl_provider.h"
   header "grpc_posix.h"
   header "grpc_security.h"
   header "grpc_security_constants.h"
+  header "impl/call.h"
   header "impl/channel_arg_names.h"
   header "impl/codegen/atm.h"
   header "impl/codegen/byte_buffer.h"

data/include/grpc/support/port_platform.h

@@ -19,14 +19,6 @@
 #ifndef GRPC_SUPPORT_PORT_PLATFORM_H
 #define GRPC_SUPPORT_PORT_PLATFORM_H
 
-/*
- * Define GPR_BACKWARDS_COMPATIBILITY_MODE to try harder to be ABI
- * compatible with older platforms (currently only on Linux)
- * Causes:
- *  - some libc calls to be gotten via dlsym
- *  - some syscalls to be made directly
- */
-
 // [[deprecated]] attribute is only available since C++14
 #if __cplusplus >= 201402L
 #define GRPC_DEPRECATED(reason) [[deprecated(reason)]]
@@ -525,18 +517,6 @@
 #endif
 #endif /* GPR_NO_AUTODETECT_PLATFORM */
 
-#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
-/*
- * For backward compatibility mode, reset _FORTIFY_SOURCE to prevent
- * a library from having non-standard symbols such as __asprintf_chk.
- * This helps non-glibc systems such as alpine using musl to find symbols.
- */
-#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
-#undef _FORTIFY_SOURCE
-#define _FORTIFY_SOURCE 0
-#endif
-#endif
-
 #if defined(__has_include)
 #if __has_include(<atomic>)
 #define GRPC_HAS_CXX11_ATOMIC
@@ -690,6 +670,18 @@ typedef unsigned __int64 uint64_t;
 #endif
 #endif
 
+#ifndef GRPC_REINITIALIZES
+#if defined(__clang__)
+#if GPR_HAS_CPP_ATTRIBUTE(clang::reinitializes)
+#define GRPC_REINITIALIZES [[clang::reinitializes]]
+#else
+#define GRPC_REINITIALIZES
+#endif
+#else
+#define GRPC_REINITIALIZES
+#endif
+#endif
+
 #ifndef GPR_HAS_ATTRIBUTE
 #ifdef __has_attribute
 #define GPR_HAS_ATTRIBUTE(a) __has_attribute(a)

data/src/core/client_channel/backend_metric.cc

@@ -0,0 +1,95 @@
+//
+// Copyright 2019 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/client_channel/backend_metric.h"
+
+#include <string.h>
+
+#include <map>
+
+#include "absl/strings/string_view.h"
+#include "upb/base/string_view.h"
+#include "upb/mem/arena.hpp"
+#include "upb/message/map.h"
+#include "xds/data/orca/v3/orca_load_report.upb.h"
+
+namespace grpc_core {
+
+namespace {
+
+template <typename EntryType>
+std::map<absl::string_view, double> ParseMap(
+    xds_data_orca_v3_OrcaLoadReport* msg,
+    const EntryType* (*entry_func)(const xds_data_orca_v3_OrcaLoadReport*,
+                                   size_t*),
+    upb_StringView (*key_func)(const EntryType*),
+    double (*value_func)(const EntryType*),
+    BackendMetricAllocatorInterface* allocator) {
+  std::map<absl::string_view, double> result;
+  size_t i = kUpb_Map_Begin;
+  while (true) {
+    const auto* entry = entry_func(msg, &i);
+    if (entry == nullptr) break;
+    upb_StringView key_view = key_func(entry);
+    char* key = allocator->AllocateString(key_view.size);
+    memcpy(key, key_view.data, key_view.size);
+    result[absl::string_view(key, key_view.size)] = value_func(entry);
+  }
+  return result;
+}
+
+}  // namespace
+
+const BackendMetricData* ParseBackendMetricData(
+    absl::string_view serialized_load_report,
+    BackendMetricAllocatorInterface* allocator) {
+  upb::Arena upb_arena;
+  xds_data_orca_v3_OrcaLoadReport* msg = xds_data_orca_v3_OrcaLoadReport_parse(
+      serialized_load_report.data(), serialized_load_report.size(),
+      upb_arena.ptr());
+  if (msg == nullptr) return nullptr;
+  BackendMetricData* backend_metric_data =
+      allocator->AllocateBackendMetricData();
+  backend_metric_data->cpu_utilization =
+      xds_data_orca_v3_OrcaLoadReport_cpu_utilization(msg);
+  backend_metric_data->mem_utilization =
+      xds_data_orca_v3_OrcaLoadReport_mem_utilization(msg);
+  backend_metric_data->application_utilization =
+      xds_data_orca_v3_OrcaLoadReport_application_utilization(msg);
+  backend_metric_data->qps =
+      xds_data_orca_v3_OrcaLoadReport_rps_fractional(msg);
+  backend_metric_data->eps = xds_data_orca_v3_OrcaLoadReport_eps(msg);
+  backend_metric_data->request_cost =
+      ParseMap<xds_data_orca_v3_OrcaLoadReport_RequestCostEntry>(
+          msg, xds_data_orca_v3_OrcaLoadReport_request_cost_next,
+          xds_data_orca_v3_OrcaLoadReport_RequestCostEntry_key,
+          xds_data_orca_v3_OrcaLoadReport_RequestCostEntry_value, allocator);
+  backend_metric_data->utilization =
+      ParseMap<xds_data_orca_v3_OrcaLoadReport_UtilizationEntry>(
+          msg, xds_data_orca_v3_OrcaLoadReport_utilization_next,
+          xds_data_orca_v3_OrcaLoadReport_UtilizationEntry_key,
+          xds_data_orca_v3_OrcaLoadReport_UtilizationEntry_value, allocator);
+  backend_metric_data->named_metrics =
+      ParseMap<xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry>(
+          msg, xds_data_orca_v3_OrcaLoadReport_named_metrics_next,
+          xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry_key,
+          xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry_value, allocator);
+  return backend_metric_data;
+}
+
+}  // namespace grpc_core