grpc 1.73.0 → 1.74.0

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");
   }