grpc 1.54.2 → 1.56.0.pre3

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

@@ -21,16 +21,15 @@
 
 #include <utility>
 
-#include "absl/strings/string_view.h"
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/lib/channel/context.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
-#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
-#include "src/core/lib/service_config/service_config_parser.h"
 
 //
 // This file contains internal interfaces used to allow various plugins
@@ -38,75 +37,39 @@
 // ClientChannel that is not normally accessible via external APIs.
 //
 
+// Channel arg key for health check service name.
+#define GRPC_ARG_HEALTH_CHECK_SERVICE_NAME \
+  "grpc.internal.health_check_service_name"
+
 namespace grpc_core {
 
 // Internal type for LB call state interface.  Provides an interface for
 // LB policies to access internal call attributes.
 class ClientChannelLbCallState : public LoadBalancingPolicy::CallState {
  public:
-  virtual absl::string_view GetCallAttribute(UniqueTypeName type) = 0;
+  virtual ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
+      UniqueTypeName type) const = 0;
 };
 
-// Internal type for ServiceConfigCallData.  Provides access to the
-// CallDispatchController.
+// Internal type for ServiceConfigCallData.  Handles call commits.
 class ClientChannelServiceConfigCallData : public ServiceConfigCallData {
  public:
-  ClientChannelServiceConfigCallData(
-      RefCountedPtr<ServiceConfig> service_config,
-      const ServiceConfigParser::ParsedConfigVector* method_configs,
-      ServiceConfigCallData::CallAttributes call_attributes,
-      ConfigSelector::CallDispatchController* call_dispatch_controller,
-      grpc_call_context_element* call_context)
-      : ServiceConfigCallData(std::move(service_config), method_configs,
-                              std::move(call_attributes)),
-        call_dispatch_controller_(call_dispatch_controller) {
-    call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = this;
-    call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].destroy = Destroy;
-  }
+  ClientChannelServiceConfigCallData(Arena* arena,
+                                     grpc_call_context_element* call_context)
+      : ServiceConfigCallData(arena, call_context) {}
 
-  ConfigSelector::CallDispatchController* call_dispatch_controller() {
-    return &call_dispatch_controller_;
+  void SetOnCommit(absl::AnyInvocable<void()> on_commit) {
+    GPR_ASSERT(on_commit_ == nullptr);
+    on_commit_ = std::move(on_commit);
   }
 
- private:
-  // A wrapper for the CallDispatchController returned by the ConfigSelector.
-  // Handles the case where the ConfigSelector doees not return any
-  // CallDispatchController.
-  // Also ensures that we call Commit() at most once, which allows the
-  // client channel code to call Commit() when the call is complete in case
-  // it wasn't called earlier, without needing to know whether or not it was.
-  class CallDispatchControllerWrapper
-      : public ConfigSelector::CallDispatchController {
-   public:
-    explicit CallDispatchControllerWrapper(
-        ConfigSelector::CallDispatchController* call_dispatch_controller)
-        : call_dispatch_controller_(call_dispatch_controller) {}
-
-    bool ShouldRetry() override {
-      if (call_dispatch_controller_ != nullptr) {
-        return call_dispatch_controller_->ShouldRetry();
-      }
-      return true;
-    }
-
-    void Commit() override {
-      if (call_dispatch_controller_ != nullptr && !commit_called_) {
-        call_dispatch_controller_->Commit();
-        commit_called_ = true;
-      }
-    }
-
-   private:
-    ConfigSelector::CallDispatchController* call_dispatch_controller_;
-    bool commit_called_ = false;
-  };
-
-  static void Destroy(void* ptr) {
-    auto* self = static_cast<ClientChannelServiceConfigCallData*>(ptr);
-    self->~ClientChannelServiceConfigCallData();
+  void Commit() {
+    auto on_commit = std::move(on_commit_);
+    if (on_commit != nullptr) on_commit();
   }
 
-  CallDispatchControllerWrapper call_dispatch_controller_;
+ private:
+  absl::AnyInvocable<void()> on_commit_;
 };
 
 }  // namespace grpc_core

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

@@ -76,8 +76,8 @@ void ClientChannelGlobalParsedConfig::JsonPostLoad(const Json& json,
   // Parse LB config.
   {
     ValidationErrors::ScopedField field(errors, ".loadBalancingConfig");
-    auto it = json.object_value().find("loadBalancingConfig");
-    if (it != json.object_value().end()) {
+    auto it = json.object().find("loadBalancingConfig");
+    if (it != json.object().end()) {
       auto config = lb_policy_registry.ParseLoadBalancingConfig(it->second);
       if (!config.ok()) {
         errors->AddError(config.status().message());

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

@@ -24,20 +24,19 @@
 #include <utility>
 #include <vector>
 
-#include "absl/status/statusor.h"
+#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/filters/client_channel/client_channel_internal.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
-#include "src/core/lib/service_config/service_config_call_data.h"
-#include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
@@ -50,36 +49,10 @@ namespace grpc_core {
 // MethodConfig and provide input to LB policies on a per-call basis.
 class ConfigSelector : public RefCounted<ConfigSelector> {
  public:
-  // An interface to be used by the channel when dispatching calls.
-  class CallDispatchController {
-   public:
-    virtual ~CallDispatchController() = default;
-
-    // Called by the channel to decide if it should retry the call upon a
-    // failure.
-    virtual bool ShouldRetry() = 0;
-
-    // Called by the channel when no more LB picks will be performed for
-    // the call.
-    virtual void Commit() = 0;
-  };
-
   struct GetCallConfigArgs {
     grpc_metadata_batch* initial_metadata;
     Arena* arena;
-  };
-
-  struct CallConfig {
-    // The per-method parsed configs that will be passed to
-    // ServiceConfigCallData.
-    const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
-    // A ref to the service config that contains method_configs, held by
-    // the call to ensure that method_configs lives long enough.
-    RefCountedPtr<ServiceConfig> service_config;
-    // Call attributes that will be accessible to LB policy implementations.
-    ServiceConfigCallData::CallAttributes call_attributes;
-    // Call dispatch controller.
-    CallDispatchController* call_dispatch_controller = nullptr;
+    ClientChannelServiceConfigCallData* service_config_call_data;
   };
 
   ~ConfigSelector() override = default;
@@ -99,7 +72,7 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
 
   // Returns the call config to use for the call, or a status to fail
   // the call with.
-  virtual absl::StatusOr<CallConfig> GetCallConfig(GetCallConfigArgs args) = 0;
+  virtual absl::Status GetCallConfig(GetCallConfigArgs args) = 0;
 
   grpc_arg MakeChannelArg() const;
   static RefCountedPtr<ConfigSelector> GetFromChannelArgs(
@@ -129,14 +102,14 @@ class DefaultConfigSelector : public ConfigSelector {
 
   const char* name() const override { return "default"; }
 
-  absl::StatusOr<CallConfig> GetCallConfig(GetCallConfigArgs args) override {
-    CallConfig call_config;
+  absl::Status GetCallConfig(GetCallConfigArgs args) override {
     Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
     GPR_ASSERT(path != nullptr);
-    call_config.method_configs =
+    auto* parsed_method_configs =
         service_config_->GetMethodParsedConfigVector(path->c_slice());
-    call_config.service_config = service_config_;
-    return call_config;
+    args.service_config_call_data->SetServiceConfig(service_config_,
+                                                    parsed_method_configs);
+    return absl::OkStatus();
   }
 
   // Only comparing the ConfigSelector itself, not the underlying

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

@@ -20,15 +20,19 @@
 
 #include "src/core/ext/filters/client_channel/http_proxy.h"
 
+#include <stdint.h>
 #include <string.h>
 
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
@@ -39,6 +43,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/env.h"
@@ -52,6 +58,31 @@
 namespace grpc_core {
 namespace {
 
+bool ServerInCIDRRange(absl::string_view server_host,
+                       absl::string_view no_proxy_entry) {
+  auto server_address = StringToSockaddr(server_host, 0);
+  if (!server_address.ok()) {
+    return false;
+  }
+  std::pair<absl::string_view, absl::string_view> possible_cidr =
+      absl::StrSplit(no_proxy_entry, absl::MaxSplits('/', 2),
+                     absl::SkipEmpty());
+  if (possible_cidr.first.empty() || possible_cidr.second.empty()) {
+    return false;
+  }
+  auto proxy_address = StringToSockaddr(possible_cidr.first, 0);
+  if (!proxy_address.ok()) {
+    return false;
+  }
+  uint32_t mask_bits = 0;
+  if (absl::SimpleAtoi(possible_cidr.second, &mask_bits)) {
+    grpc_sockaddr_mask_bits(&*proxy_address, mask_bits);
+    return grpc_sockaddr_match_subnet(&*server_address, &*proxy_address,
+                                      mask_bits);
+  }
+  return false;
+}
+
 ///
 /// Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
 /// proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
@@ -168,7 +199,9 @@ absl::optional<std::string> HttpProxyMapper::MapName(
       std::vector<absl::string_view> no_proxy_hosts =
           absl::StrSplit(*no_proxy_str, ',', absl::SkipEmpty());
       for (const auto& no_proxy_entry : no_proxy_hosts) {
-        if (absl::EndsWithIgnoreCase(server_host, no_proxy_entry)) {
+        auto entry = absl::StripAsciiWhitespace(no_proxy_entry);
+        if (absl::EndsWithIgnoreCase(server_host, entry) ||
+            ServerInCIDRRange(server_host, entry)) {
           gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
                   std::string(server_uri).c_str());
           use_proxy = false;

data/src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h

@@ -32,6 +32,9 @@ struct BackendMetricData {
   /// Memory utilization expressed as a fraction of available memory
   /// resources.
   double mem_utilization = -1;
+  /// Application specific utilization expressed as a fraction of available
+  /// resources.
+  double application_utilization = -1;
   /// Total queries per second being served by the backend across all services.
   double qps = -1;
   /// Total errors per second reported by the backend across all services.

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc

@@ -54,6 +54,7 @@
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/json.h>
 
 // IWYU pragma: no_include <sys/socket.h>
 
@@ -188,11 +189,11 @@ class GrpcLbConfig : public LoadBalancingPolicy::Config {
     ValidationErrors::ScopedField field(errors, ".childPolicy");
     Json child_policy_config_json_tmp;
     const Json* child_policy_config_json;
-    auto it = json.object_value().find("childPolicy");
-    if (it == json.object_value().end()) {
-      child_policy_config_json_tmp = Json::Array{Json::Object{
-          {"round_robin", Json::Object()},
-      }};
+    auto it = json.object().find("childPolicy");
+    if (it == json.object().end()) {
+      child_policy_config_json_tmp = Json::FromArray({Json::FromObject({
+          {"round_robin", Json::FromObject({})},
+      })});
       child_policy_config_json = &child_policy_config_json_tmp;
     } else {
       child_policy_config_json = &it->second;
@@ -1891,7 +1892,7 @@ class GrpcLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    return LoadRefCountedFromJson<GrpcLbConfig>(
+    return LoadFromJson<RefCountedPtr<GrpcLbConfig>>(
         json, JsonArgs(), "errors validating grpclb LB policy config");
   }
 };

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.cc

@@ -26,7 +26,7 @@
 
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/timestamp.upb.h"
-#include "upb/upb.h"
+#include "upb/base/string_view.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h

@@ -24,7 +24,7 @@
 
 #include <vector>
 
-#include "upb/arena.h"
+#include "upb/mem/arena.h"
 
 #include <grpc/slice.h>