grpc 1.73.0 → 1.75.0

data/src/core/xds/grpc/xds_server_grpc.cc

@@ -27,6 +27,7 @@
 #include "absl/strings/string_view.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/util/down_cast.h"
+#include "src/core/util/env.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/json/json_writer.h"
 
@@ -82,29 +83,40 @@ const JsonLoaderInterface* GrpcXdsServer::JsonLoader(const JsonArgs&) {
 
 namespace {
 
-struct ChannelCreds {
+struct ChannelOrCallCreds {
   std::string type;
   Json::Object config;
 
   static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
     static const auto* loader =
-        JsonObjectLoader<ChannelCreds>()
-            .Field("type", &ChannelCreds::type)
-            .OptionalField("config", &ChannelCreds::config)
+        JsonObjectLoader<ChannelOrCallCreds>()
+            .Field("type", &ChannelOrCallCreds::type)
+            .OptionalField("config", &ChannelOrCallCreds::config)
             .Finish();
     return loader;
   }
 };
 
+// TODO(roth): Remove this guard once we have reports from OSS Istio
+// users that this works properly.
+bool XdsBootstrapCallCredsEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_BOOTSTRAP_CALL_CREDS");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
 }  // namespace
 
 void GrpcXdsServer::JsonPostLoad(const Json& json, const JsonArgs& args,
                                  ValidationErrors* errors) {
+  // Parse "channel_creds".
   RefCountedPtr<ChannelCredsConfig> channel_creds_config;
   {
-    // Parse "channel_creds".
-    auto channel_creds_list = LoadJsonObjectField<std::vector<ChannelCreds>>(
-        json.object(), args, "channel_creds", errors);
+    auto channel_creds_list =
+        LoadJsonObjectField<std::vector<ChannelOrCallCreds>>(
+            json.object(), args, "channel_creds", errors);
     if (channel_creds_list.has_value()) {
       ValidationErrors::ScopedField field(errors, ".channel_creds");
       for (size_t i = 0; i < channel_creds_list->size(); ++i) {
@@ -128,6 +140,26 @@ void GrpcXdsServer::JsonPostLoad(const Json& json, const JsonArgs& args,
       }
     }
   }
+  // Parse "call_creds".
+  std::vector<RefCountedPtr<CallCredsConfig>> call_creds_configs;
+  if (XdsBootstrapCallCredsEnabled()) {
+    auto call_creds_list = LoadJsonObjectField<std::vector<ChannelOrCallCreds>>(
+        json.object(), args, "call_creds", errors);
+    if (call_creds_list.has_value()) {
+      ValidationErrors::ScopedField field(errors, ".call_creds");
+      for (size_t i = 0; i < call_creds_list->size(); ++i) {
+        ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
+        auto& creds = (*call_creds_list)[i];
+        if (CoreConfiguration::Get().call_creds_registry().IsSupported(
+                creds.type)) {
+          ValidationErrors::ScopedField field(errors, ".config");
+          call_creds_configs.push_back(
+              CoreConfiguration::Get().call_creds_registry().ParseConfig(
+                  creds.type, Json::FromObject(creds.config), args, errors));
+        }
+      }
+    }
+  }
   // Parse "server_features".
   {
     ValidationErrors::ScopedField field(errors, ".server_features");
@@ -155,7 +187,8 @@ void GrpcXdsServer::JsonPostLoad(const Json& json, const JsonArgs& args,
                                       json.object(), args, "server_uri", errors)
                                       .value_or("");
   server_target_ = std::make_shared<GrpcXdsServerTarget>(
-      std::move(server_uri_target), std::move(channel_creds_config));
+      std::move(server_uri_target), std::move(channel_creds_config),
+      std::move(call_creds_configs));
 }
 
 std::string GrpcXdsServer::Key() const {
@@ -175,9 +208,14 @@ std::string GrpcXdsServerTarget::Key() const {
   parts.push_back("{");
   parts.push_back(absl::StrCat("server_uri=", server_uri_));
   if (channel_creds_config_ != nullptr) {
-    parts.push_back(absl::StrCat("creds_type=", channel_creds_config_->type()));
     parts.push_back(
-        absl::StrCat("creds_config=", channel_creds_config_->ToString()));
+        absl::StrCat("channel_creds={type=", channel_creds_config_->type(),
+                     ", config=", channel_creds_config_->ToString(), "}"));
+  }
+  for (const auto& call_creds_config : call_creds_configs_) {
+    parts.push_back(absl::StrCat("call_creds={type=", call_creds_config->type(),
+                                 ", config=", call_creds_config->ToString(),
+                                 "}"));
   }
   parts.push_back("}");
   return absl::StrJoin(parts, ",");
@@ -185,9 +223,21 @@ std::string GrpcXdsServerTarget::Key() const {
 
 bool GrpcXdsServerTarget::Equals(const XdsServerTarget& other) const {
   const auto& o = DownCast<const GrpcXdsServerTarget&>(other);
-  return (server_uri_ == o.server_uri_ &&
-          channel_creds_config_->type() == o.channel_creds_config_->type() &&
-          channel_creds_config_->Equals(*o.channel_creds_config_));
+  if (server_uri_ != o.server_uri_) return false;
+  if (channel_creds_config_->type() != o.channel_creds_config_->type() ||
+      !channel_creds_config_->Equals(*o.channel_creds_config_)) {
+    return false;
+  }
+  if (call_creds_configs_.size() != o.call_creds_configs_.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < call_creds_configs_.size(); ++i) {
+    if (call_creds_configs_[i]->type() != o.call_creds_configs_[i]->type() ||
+        !call_creds_configs_[i]->Equals(*o.call_creds_configs_[i])) {
+      return false;
+    }
+  }
+  return true;
 }
 
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_server_grpc.h

@@ -20,6 +20,7 @@
 #include <set>
 #include <string>
 
+#include "src/core/credentials/call/call_creds_registry.h"
 #include "src/core/credentials/transport/channel_creds_registry.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
@@ -35,9 +36,11 @@ class GrpcXdsServerTarget final : public GrpcXdsServerInterface {
  public:
   explicit GrpcXdsServerTarget(
       std::string server_uri,
-      RefCountedPtr<ChannelCredsConfig> channel_creds_config)
+      RefCountedPtr<ChannelCredsConfig> channel_creds_config,
+      std::vector<RefCountedPtr<CallCredsConfig>> call_creds_configs)
       : server_uri_(std::move(server_uri)),
-        channel_creds_config_(std::move(channel_creds_config)) {}
+        channel_creds_config_(std::move(channel_creds_config)),
+        call_creds_configs_(std::move(call_creds_configs)) {}
 
   bool Equals(const XdsServerTarget& other) const override;
   std::string Key() const override;
@@ -45,10 +48,15 @@ class GrpcXdsServerTarget final : public GrpcXdsServerInterface {
   RefCountedPtr<ChannelCredsConfig> channel_creds_config() const override {
     return channel_creds_config_;
   }
+  const std::vector<RefCountedPtr<CallCredsConfig>>& call_creds_configs()
+      const override {
+    return call_creds_configs_;
+  }
 
  private:
   std::string server_uri_;
   RefCountedPtr<ChannelCredsConfig> channel_creds_config_;
+  std::vector<RefCountedPtr<CallCredsConfig>> call_creds_configs_;
 };
 
 class GrpcXdsServer final : public XdsBootstrap::XdsServer {

data/src/core/xds/grpc/xds_server_grpc_interface.h

@@ -17,6 +17,7 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_SERVER_GRPC_INTERFACE_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_SERVER_GRPC_INTERFACE_H
 
+#include "src/core/credentials/call/call_creds_registry.h"
 #include "src/core/credentials/transport/channel_creds_registry.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
@@ -26,6 +27,9 @@ namespace grpc_core {
 class GrpcXdsServerInterface : public XdsBootstrap::XdsServerTarget {
  public:
   virtual RefCountedPtr<ChannelCredsConfig> channel_creds_config() const = 0;
+
+  virtual const std::vector<RefCountedPtr<CallCredsConfig>>&
+  call_creds_configs() const = 0;
 };
 
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_transport_grpc.cc

@@ -35,7 +35,9 @@
 #include "absl/strings/str_cat.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/call/composite/composite_call_credentials.h"
 #include "src/core/credentials/transport/channel_creds_registry.h"
+#include "src/core/credentials/transport/composite/composite_channel_credentials.h"
 #include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -255,6 +257,22 @@ RefCountedPtr<Channel> CreateXdsChannel(const ChannelArgs& args,
   RefCountedPtr<grpc_channel_credentials> channel_creds =
       CoreConfiguration::Get().channel_creds_registry().CreateChannelCreds(
           server.channel_creds_config());
+  RefCountedPtr<grpc_call_credentials> call_creds;
+  for (const auto& call_creds_config : server.call_creds_configs()) {
+    RefCountedPtr<grpc_call_credentials> creds =
+        CoreConfiguration::Get().call_creds_registry().CreateCallCreds(
+            call_creds_config);
+    if (call_creds == nullptr) {
+      call_creds = std::move(creds);
+    } else {
+      call_creds = MakeRefCounted<grpc_composite_call_credentials>(
+          std::move(call_creds), std::move(creds));
+    }
+  }
+  if (call_creds != nullptr) {
+    channel_creds = MakeRefCounted<grpc_composite_channel_credentials>(
+        std::move(channel_creds), std::move(call_creds));
+  }
   return RefCountedPtr<Channel>(Channel::FromC(grpc_channel_create(
       server.server_uri().c_str(), channel_creds.get(), args.ToC().get())));
 }

data/src/core/xds/xds_client/xds_bootstrap.h

@@ -88,6 +88,8 @@ class XdsBootstrap {
     virtual ~Authority() = default;
 
     virtual std::vector<const XdsServer*> servers() const = 0;
+
+    virtual bool FallbackOnReachabilityOnly() const = 0;
   };
 
   virtual ~XdsBootstrap() = default;

data/src/core/xds/xds_client/xds_client.cc

@@ -47,8 +47,10 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/env.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/util/uri.h"
@@ -68,6 +70,18 @@
 
 namespace grpc_core {
 
+namespace {
+
+bool XdsEndpointFallbackEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_ENDPOINT_FALLBACK");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
+}  // namespace
+
 using ::grpc_event_engine::experimental::EventEngine;
 
 //
@@ -489,13 +503,20 @@ void XdsClient::XdsChannel::UnsubscribeLocked(const XdsResourceType* type,
 
 bool XdsClient::XdsChannel::MaybeFallbackLocked(
     const std::string& authority, AuthorityState& authority_state) {
-  if (!xds_client_->HasUncachedResources(authority_state)) {
-    return false;
-  }
   std::vector<const XdsBootstrap::XdsServer*> xds_servers;
+  bool fallback_on_reachability_only = false;
   if (authority != kOldStyleAuthority) {
-    xds_servers =
-        xds_client_->bootstrap().LookupAuthority(authority)->servers();
+    auto* bootstrap_authority =
+        xds_client_->bootstrap().LookupAuthority(authority);
+    xds_servers = bootstrap_authority->servers();
+    if (XdsEndpointFallbackEnabled()) {
+      fallback_on_reachability_only =
+          bootstrap_authority->FallbackOnReachabilityOnly();
+    }
+  }
+  if (!fallback_on_reachability_only &&
+      !xds_client_->HasUncachedResources(authority_state)) {
+    return false;
   }
   if (xds_servers.empty()) xds_servers = xds_client_->bootstrap().servers();
   for (size_t i = authority_state.xds_channels.size(); i < xds_servers.size();

data/src/ruby/ext/grpc/extconf.rb

@@ -114,6 +114,8 @@ env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\""'
 require_relative '../../lib/grpc/version'
 env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"' + GRPC::VERSION + '\""'
 env_append 'CPPFLAGS', '-DGRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK=1'
+env_append 'CPPFLAGS', '-DGRPC_ENABLE_FORK_SUPPORT=1'
+env_append 'CPPFLAGS', '-DGRPC_ENABLE_FORK_SUPPORT_DEFAULT=false'
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)

data/src/ruby/ext/grpc/rb_call.c

@@ -808,12 +808,6 @@ struct call_run_batch_args {
   run_batch_stack* st;
 };
 
-static void cancel_call_unblock_func(void* arg) {
-  grpc_absl_log(GPR_DEBUG, "GRPC_RUBY: cancel_call_unblock_func");
-  grpc_call* call = (grpc_call*)arg;
-  grpc_call_cancel(call, NULL);
-}
-
 static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
   grpc_rb_fork_unsafe_begin();
   struct call_run_batch_args* args = (struct call_run_batch_args*)value_args;
@@ -836,8 +830,7 @@ static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
              grpc_call_error_detail_of(err), err);
   }
   ev = rb_completion_queue_pluck(args->call->queue, tag,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME),
-                                 cancel_call_unblock_func, args->call->wrapped);
+                                 gpr_inf_future(GPR_CLOCK_REALTIME), "call op");
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
   }