grpc 1.45.0 → 1.47.0

data/src/core/ext/filters/client_channel/backend_metric.cc

@@ -18,7 +18,12 @@
 
 #include "src/core/ext/filters/client_channel/backend_metric.h"
 
+#include <string.h>
+
+#include <map>
+
 #include "absl/strings/string_view.h"
+#include "upb/upb.h"
 #include "upb/upb.hpp"
 #include "xds/data/orca/v3/orca_load_report.upb.h"
 
@@ -32,14 +37,15 @@ std::map<absl::string_view, double> ParseMap(
     const EntryType* (*entry_func)(const xds_data_orca_v3_OrcaLoadReport*,
                                    size_t*),
     upb_StringView (*key_func)(const EntryType*),
-    double (*value_func)(const EntryType*), Arena* arena) {
+    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 = static_cast<char*>(arena->Alloc(key_view.size));
+    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);
   }
@@ -48,31 +54,30 @@ std::map<absl::string_view, double> ParseMap(
 
 }  // namespace
 
-const LoadBalancingPolicy::BackendMetricAccessor::BackendMetricData*
-ParseBackendMetricData(const Slice& serialized_load_report, Arena* arena) {
+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(
-      reinterpret_cast<const char*>(serialized_load_report.begin()),
-      serialized_load_report.size(), upb_arena.ptr());
+      serialized_load_report.data(), serialized_load_report.size(),
+      upb_arena.ptr());
   if (msg == nullptr) return nullptr;
-  auto* backend_metric_data = arena->New<
-      LoadBalancingPolicy::BackendMetricAccessor::BackendMetricData>();
+  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->requests_per_second =
-      xds_data_orca_v3_OrcaLoadReport_rps(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, arena);
+          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, arena);
+          xds_data_orca_v3_OrcaLoadReport_UtilizationEntry_value, allocator);
   return backend_metric_data;
 }
 

data/src/core/ext/filters/client_channel/backend_metric.h

@@ -19,19 +19,29 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
+#include <stddef.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy.h"
-#include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/slice/slice.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
 
 namespace grpc_core {
 
-// Parses the serialized load report and allocates a BackendMetricData
-// object on the arena.
-const LoadBalancingPolicy::BackendMetricAccessor::BackendMetricData*
-ParseBackendMetricData(const Slice& serialized_load_report, Arena* arena);
+class BackendMetricAllocatorInterface {
+ public:
+  virtual ~BackendMetricAllocatorInterface() = default;
+
+  virtual BackendMetricData* AllocateBackendMetricData() = 0;
+
+  virtual char* AllocateString(size_t size) = 0;
+};
+
+// Parses the serialized load report and populates out.
+// Returns false on error.
+const BackendMetricData* ParseBackendMetricData(
+    absl::string_view serialized_load_report,
+    BackendMetricAllocatorInterface* allocator);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKEND_METRIC_H */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKEND_METRIC_H

data/src/core/ext/filters/client_channel/backup_poller.cc

@@ -20,22 +20,22 @@
 
 #include "src/core/ext/filters/client_channel/backup_poller.h"
 
-#include <grpc/grpc.h>
+#include <inttypes.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/surface/channel.h"
-#include "src/core/lib/surface/completion_queue.h"
 
 #define DEFAULT_POLL_INTERVAL_MS 5000
 

data/src/core/ext/filters/client_channel/backup_poller.h

@@ -21,10 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
-
-#include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gprpp/global_config.h"
+#include "src/core/lib/gprpp/global_config_generic.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 
 GPR_GLOBAL_CONFIG_DECLARE_INT32(grpc_client_channel_backup_poll_interval_ms);
 

data/src/core/ext/filters/client_channel/channel_connectivity.cc

@@ -16,37 +16,58 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <inttypes.h>
+
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/dual_ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/lame_client.h"
 
+namespace grpc_core {
 namespace {
 
-bool IsLameChannel(grpc_channel* channel) {
+bool IsLameChannel(Channel* channel) {
   grpc_channel_element* elem =
-      grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
-  return elem->filter == &grpc_lame_filter;
+      grpc_channel_stack_last_element(channel->channel_stack());
+  return elem->filter == &LameClientFilter::kFilter;
 }
 
 }  // namespace
+}  // namespace grpc_core
 
 grpc_connectivity_state grpc_channel_check_connectivity_state(
-    grpc_channel* channel, int try_to_connect) {
+    grpc_channel* c_channel, int try_to_connect) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE(
       "grpc_channel_check_connectivity_state(channel=%p, try_to_connect=%d)", 2,
-      (channel, try_to_connect));
+      (c_channel, try_to_connect));
+  grpc_core::Channel* channel = grpc_core::Channel::FromC(c_channel);
   // Forward through to the underlying client channel.
   grpc_core::ClientChannel* client_channel =
       grpc_core::ClientChannel::GetFromChannel(channel);
   if (GPR_UNLIKELY(client_channel == nullptr)) {
-    if (IsLameChannel(channel)) return GRPC_CHANNEL_TRANSIENT_FAILURE;
+    if (grpc_core::IsLameChannel(channel)) {
+      return GRPC_CHANNEL_TRANSIENT_FAILURE;
+    }
     gpr_log(GPR_ERROR,
             "grpc_channel_check_connectivity_state called on something that is "
             "not a client channel");
@@ -55,11 +76,12 @@ grpc_connectivity_state grpc_channel_check_connectivity_state(
   return client_channel->CheckConnectivityState(try_to_connect);
 }
 
-int grpc_channel_num_external_connectivity_watchers(grpc_channel* channel) {
+int grpc_channel_num_external_connectivity_watchers(grpc_channel* c_channel) {
+  grpc_core::Channel* channel = grpc_core::Channel::FromC(c_channel);
   grpc_core::ClientChannel* client_channel =
       grpc_core::ClientChannel::GetFromChannel(channel);
   if (client_channel == nullptr) {
-    if (!IsLameChannel(channel)) {
+    if (!grpc_core::IsLameChannel(channel)) {
       gpr_log(GPR_ERROR,
               "grpc_channel_num_external_connectivity_watchers called on "
               "something that is not a client channel");
@@ -70,7 +92,8 @@ int grpc_channel_num_external_connectivity_watchers(grpc_channel* channel) {
 }
 
 int grpc_channel_support_connectivity_watcher(grpc_channel* channel) {
-  return grpc_core::ClientChannel::GetFromChannel(channel) != nullptr;
+  return grpc_core::ClientChannel::GetFromChannel(
+             grpc_core::Channel::FromC(channel)) != nullptr;
 }
 
 namespace grpc_core {
@@ -78,22 +101,25 @@ namespace {
 
 class StateWatcher : public DualRefCounted<StateWatcher> {
  public:
-  StateWatcher(grpc_channel* channel, grpc_completion_queue* cq, void* tag,
+  StateWatcher(grpc_channel* c_channel, grpc_completion_queue* cq, void* tag,
                grpc_connectivity_state last_observed_state,
                gpr_timespec deadline)
-      : channel_(channel), cq_(cq), tag_(tag), state_(last_observed_state) {
+      : channel_(Channel::FromC(c_channel)->Ref()),
+        cq_(cq),
+        tag_(tag),
+        state_(last_observed_state) {
     GPR_ASSERT(grpc_cq_begin_op(cq, tag));
-    GRPC_CHANNEL_INTERNAL_REF(channel, "watch_channel_connectivity");
     GRPC_CLOSURE_INIT(&on_complete_, WatchComplete, this, nullptr);
     GRPC_CLOSURE_INIT(&on_timeout_, TimeoutComplete, this, nullptr);
-    ClientChannel* client_channel = ClientChannel::GetFromChannel(channel);
+    ClientChannel* client_channel =
+        ClientChannel::GetFromChannel(channel_.get());
     if (client_channel == nullptr) {
       // If the target URI used to create the channel was invalid, channel
       // stack initialization failed, and that caused us to create a lame
       // channel.  In that case, connectivity state will never change (it
       // will always be TRANSIENT_FAILURE), so we don't actually start a
       // watch, but we are hiding that fact from the application.
-      if (IsLameChannel(channel)) {
+      if (IsLameChannel(channel_.get())) {
         // Ref from object creation is held by timer callback.
         StartTimer(Timestamp::FromTimespecRoundUp(deadline));
         return;
@@ -114,10 +140,6 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
         &on_complete_, watcher_timer_init_state->closure());
   }
 
-  ~StateWatcher() override {
-    GRPC_CHANNEL_INTERNAL_UNREF(channel_, "watch_channel_connectivity");
-  }
-
  private:
   // A fire-and-forget object used to delay starting the timer until the
   // ClientChannel actually starts the watch.
@@ -160,7 +182,7 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
     self->timer_fired_ = error == GRPC_ERROR_NONE;
     // If this is a client channel (not a lame channel), cancel the watch.
     ClientChannel* client_channel =
-        ClientChannel::GetFromChannel(self->channel_);
+        ClientChannel::GetFromChannel(self->channel_.get());
     if (client_channel != nullptr) {
       client_channel->CancelExternalConnectivityWatcher(&self->on_complete_);
     }
@@ -184,7 +206,7 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
     self->WeakUnref();
   }
 
-  grpc_channel* channel_;
+  RefCountedPtr<Channel> channel_;
   grpc_completion_queue* cq_;
   void* tag_;