grpc 1.55.0 → 1.56.0.pre3

data/src/core/lib/service_config/service_config_impl.cc

@@ -121,7 +121,8 @@ RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
     service_config->parsed_method_config_vectors_storage_.reserve(
         method_configs->size());
     for (size_t i = 0; i < method_configs->size(); ++i) {
-      const Json::Object& method_config_json = (*method_configs)[i];
+      const Json method_config_json =
+          Json::FromObject(std::move((*method_configs)[i]));
       ValidationErrors::ScopedField field(
           errors, absl::StrCat(".methodConfig[", i, "]"));
       // Have each parser read this method config.

data/src/core/lib/surface/call.cc

@@ -195,7 +195,7 @@ class Call : public CppImplOf<Call, grpc_call> {
 
   ParentCall* GetOrCreateParentCall();
   ParentCall* parent_call();
-  Channel* channel() {
+  Channel* channel() const {
     GPR_DEBUG_ASSERT(channel_ != nullptr);
     return channel_.get();
   }
@@ -445,6 +445,8 @@ void Call::PrepareOutgoingInitialMetadata(const grpc_op& op,
   }
   // Ignore any te metadata key value pairs specified.
   md.Remove(TeMetadata());
+  // Should never come from applications
+  md.Remove(GrpcLbClientStatsMetadata());
 }
 
 void Call::ProcessIncomingInitialMetadata(grpc_metadata_batch& md) {
@@ -1047,8 +1049,8 @@ void FilterStackCall::CancelWithError(grpc_error_handle error) {
 
 void FilterStackCall::SetFinalStatus(grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_error_trace)) {
-    gpr_log(GPR_DEBUG, "set_final_status %s", is_client() ? "CLI" : "SVR");
-    gpr_log(GPR_DEBUG, "%s", StatusToString(error).c_str());
+    gpr_log(GPR_DEBUG, "set_final_status %s %s", is_client() ? "CLI" : "SVR",
+            StatusToString(error).c_str());
   }
   if (is_client()) {
     std::string status_details;
@@ -1295,8 +1297,9 @@ void FilterStackCall::BatchControl::PostCompletion() {
   FilterStackCall* call = call_;
   grpc_error_handle error = batch_error_.get();
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "tag:%p batch_error=%s", completion_data_.notify_tag.tag,
-            error.ToString().c_str());
+    gpr_log(GPR_DEBUG, "tag:%p batch_error=%s op:%s",
+            completion_data_.notify_tag.tag, error.ToString().c_str(),
+            grpc_transport_stream_op_batch_string(&op_, false).c_str());
   }
 
   if (op_.send_initial_metadata) {
@@ -1314,16 +1317,16 @@ void FilterStackCall::BatchControl::PostCompletion() {
   if (op_.send_trailing_metadata) {
     call->send_trailing_metadata_.Clear();
   }
+  if (!error.ok() && op_.recv_message && *call->receiving_buffer_ != nullptr) {
+    grpc_byte_buffer_destroy(*call->receiving_buffer_);
+    *call->receiving_buffer_ = nullptr;
+  }
   if (op_.recv_trailing_metadata) {
     // propagate cancellation to any interested children
     gpr_atm_rel_store(&call->received_final_op_atm_, 1);
     call->PropagateCancellationToChildren();
     error = absl::OkStatus();
   }
-  if (!error.ok() && op_.recv_message && *call->receiving_buffer_ != nullptr) {
-    grpc_byte_buffer_destroy(*call->receiving_buffer_);
-    *call->receiving_buffer_ = nullptr;
-  }
   batch_error_.set(absl::OkStatus());
 
   if (completion_data_.notify_tag.is_closure) {
@@ -2010,6 +2013,10 @@ class PromiseBasedCall : public Call,
     return failed_before_recv_message_.load(std::memory_order_relaxed);
   }
 
+  grpc_event_engine::experimental::EventEngine* event_engine() const final {
+    return channel()->event_engine();
+  }
+
   using Call::arena;
 
  protected:
@@ -2183,7 +2190,7 @@ class PromiseBasedCall : public Call,
   void StartRecvMessage(const grpc_op& op, const Completion& completion,
                         FirstPromise first,
                         PipeReceiver<MessageHandle>* receiver,
-                        Party::BulkSpawner& spawner);
+                        bool cancel_on_error, Party::BulkSpawner& spawner);
   void StartSendMessage(const grpc_op& op, const Completion& completion,
                         PipeSender<MessageHandle>* sender,
                         Party::BulkSpawner& spawner);
@@ -2538,7 +2545,8 @@ template <typename FirstPromiseFactory>
 void PromiseBasedCall::StartRecvMessage(
     const grpc_op& op, const Completion& completion,
     FirstPromiseFactory first_promise_factory,
-    PipeReceiver<MessageHandle>* receiver, Party::BulkSpawner& spawner) {
+    PipeReceiver<MessageHandle>* receiver, bool cancel_on_error,
+    Party::BulkSpawner& spawner) {
   if (grpc_call_trace.enabled()) {
     gpr_log(GPR_INFO, "%s[call] Start RecvMessage: %s", DebugTag().c_str(),
             CompletionString(completion).c_str());
@@ -2549,7 +2557,7 @@ void PromiseBasedCall::StartRecvMessage(
       [first_promise_factory = std::move(first_promise_factory), receiver]() {
         return Seq(first_promise_factory(), receiver->Next());
       },
-      [this,
+      [this, cancel_on_error,
        completion = AddOpToCompletion(completion, PendingOp::kReceiveMessage)](
           NextResult<MessageHandle> result) mutable {
         if (result.has_value()) {
@@ -2580,6 +2588,7 @@ void PromiseBasedCall::StartRecvMessage(
           }
           failed_before_recv_message_.store(true);
           FailCompletion(completion);
+          if (cancel_on_error) CancelWithError(absl::CancelledError());
           *recv_message_ = nullptr;
         } else {
           if (grpc_call_trace.enabled()) {
@@ -2873,7 +2882,7 @@ void ClientPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
             [this]() {
               return server_initial_metadata_.receiver.AwaitClosed();
             },
-            &server_to_client_messages_.receiver, spawner);
+            &server_to_client_messages_.receiver, false, spawner);
         break;
       case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
         spawner.Spawn(
@@ -3218,14 +3227,6 @@ void ServerPromiseBasedCall::Finish(ServerMetadataHandle result) {
             DebugTag().c_str(), recv_close_op_cancel_state_.ToString().c_str(),
             result->DebugString().c_str());
   }
-  if (recv_close_op_cancel_state_.CompleteCallWithCancelledSetTo(
-          result->get(GrpcCallWasCancelled()).value_or(true))) {
-    FinishOpOnCompletion(&recv_close_completion_,
-                         PendingOp::kReceiveCloseOnServer);
-  }
-  if (server_initial_metadata_ != nullptr) {
-    server_initial_metadata_->Close();
-  }
   const auto status =
       result->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
   channelz::ServerNode* channelz_node = server_->channelz_node();
@@ -3236,6 +3237,14 @@ void ServerPromiseBasedCall::Finish(ServerMetadataHandle result) {
       channelz_node->RecordCallFailed();
     }
   }
+  if (recv_close_op_cancel_state_.CompleteCallWithCancelledSetTo(
+          result->get(GrpcCallWasCancelled()).value_or(true))) {
+    FinishOpOnCompletion(&recv_close_completion_,
+                         PendingOp::kReceiveCloseOnServer);
+  }
+  if (server_initial_metadata_ != nullptr) {
+    server_initial_metadata_->Close();
+  }
   absl::string_view message_string;
   if (Slice* message = result->get_pointer(GrpcMessageMetadata())) {
     message_string = message->as_string_view();
@@ -3328,7 +3337,7 @@ void ServerPromiseBasedCall::CommitBatch(const grpc_op* ops, size_t nops,
         }
         StartRecvMessage(
             op, completion, []() { return []() { return Empty{}; }; },
-            client_to_server_messages_, spawner);
+            client_to_server_messages_, true, spawner);
         break;
       case GRPC_OP_SEND_STATUS_FROM_SERVER: {
         auto metadata = arena()->MakePooled<ServerMetadata>(arena());
@@ -3521,6 +3530,9 @@ grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element) {
 grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
   GRPC_API_TRACE("grpc_call_cancel(call=%p, reserved=%p)", 2, (call, reserved));
   GPR_ASSERT(reserved == nullptr);
+  if (call == nullptr) {
+    return GRPC_CALL_ERROR;
+  }
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
@@ -3536,6 +3548,9 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
       "c=%p, status=%d, description=%s, reserved=%p)",
       4, (c, (int)status, description, reserved));
   GPR_ASSERT(reserved == nullptr);
+  if (c == nullptr) {
+    return GRPC_CALL_ERROR;
+  }
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Call::FromC(c)->CancelWithStatus(status, description);
@@ -3576,7 +3591,7 @@ grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
       "reserved=%p)",
       5, (call, ops, (unsigned long)nops, tag, reserved));
 
-  if (reserved != nullptr) {
+  if (reserved != nullptr || call == nullptr) {
     return GRPC_CALL_ERROR;
   } else {
     grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;

data/src/core/lib/surface/completion_queue.cc

@@ -349,10 +349,14 @@ struct cq_callback_data {
 struct grpc_completion_queue {
   /// Once owning_refs drops to zero, we will destroy the cq
   grpc_core::RefCount owning_refs;
-
+  /// Add the paddings to fix the false sharing
+  char padding_1[GPR_CACHELINE_SIZE];
   gpr_mu* mu;
 
+  char padding_2[GPR_CACHELINE_SIZE];
   const cq_vtable* vtable;
+
+  char padding_3[GPR_CACHELINE_SIZE];
   const cq_poller_vtable* poller_vtable;
 
 #ifndef NDEBUG
@@ -1231,7 +1235,7 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
     prev = &cqd->completed_head;
     while ((c = reinterpret_cast<grpc_cq_completion*>(
                 prev->next & ~uintptr_t{1})) != &cqd->completed_head) {
-      if (c->tag == tag) {
+      if (GPR_LIKELY(c->tag == tag)) {
         prev->next = (prev->next & uintptr_t{1}) | (c->next & ~uintptr_t{1});
         if (c == cqd->completed_tail) {
           cqd->completed_tail = prev;

data/src/core/lib/surface/version.cc

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "32.0.0"; }
+const char* grpc_version_string(void) { return "33.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "grandslam"; }
+const char* grpc_g_stands_for(void) { return "galvanized"; }

data/src/core/lib/transport/batch_builder.cc

@@ -36,8 +36,8 @@ void BatchBuilder::PendingCompletion::CompletionCallback(
   auto* party = pc->batch->party.get();
   if (grpc_call_trace.enabled()) {
     gpr_log(
-        GPR_DEBUG, "%s[connected] Finish batch-component %s for %s: status=%s",
-        party->DebugTag().c_str(), std::string(pc->name()).c_str(),
+        GPR_DEBUG, "%sFinish batch-component %s for %s: status=%s",
+        pc->batch->DebugPrefix(party).c_str(), std::string(pc->name()).c_str(),
         grpc_transport_stream_op_batch_string(&pc->batch->batch, false).c_str(),
         error.ToString().c_str());
   }
@@ -71,6 +71,10 @@ BatchBuilder::Batch::Batch(grpc_transport_stream_op_batch_payload* payload,
 
 BatchBuilder::Batch::~Batch() {
   auto* arena = party->arena();
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "%s[connected] [batch %p] Destroy",
+            Activity::current()->DebugTag().c_str(), this);
+  }
   if (pending_receive_message != nullptr) {
     arena->DeletePooled(pending_receive_message);
   }
@@ -114,8 +118,8 @@ void BatchBuilder::FlushBatch() {
   GPR_ASSERT(target_.has_value());
   if (grpc_call_trace.enabled()) {
     gpr_log(
-        GPR_DEBUG, "%s[connected] Perform transport stream op batch: %p %s",
-        batch_->party->DebugTag().c_str(), &batch_->batch,
+        GPR_DEBUG, "%sPerform transport stream op batch: %p %s",
+        batch_->DebugPrefix().c_str(), &batch_->batch,
         grpc_transport_stream_op_batch_string(&batch_->batch, false).c_str());
   }
   std::exchange(batch_, nullptr)->PerformWith(*target_);
@@ -127,15 +131,14 @@ void BatchBuilder::Batch::PerformWith(Target target) {
 }
 
 ServerMetadataHandle BatchBuilder::CompleteSendServerTrailingMetadata(
-    ServerMetadataHandle sent_metadata, absl::Status send_result,
+    Batch* batch, ServerMetadataHandle sent_metadata, absl::Status send_result,
     bool actually_sent) {
   if (!send_result.ok()) {
     if (grpc_call_trace.enabled()) {
       gpr_log(GPR_DEBUG,
-              "%s[connected] Send metadata failed with error: %s, "
-              "fabricating trailing metadata",
-              Activity::current()->DebugTag().c_str(),
-              send_result.ToString().c_str());
+              "%sSend metadata failed with error: %s, fabricating trailing "
+              "metadata",
+              batch->DebugPrefix().c_str(), send_result.ToString().c_str());
     }
     sent_metadata->Clear();
     sent_metadata->Set(GrpcStatusMetadata(),
@@ -148,9 +151,9 @@ ServerMetadataHandle BatchBuilder::CompleteSendServerTrailingMetadata(
     if (grpc_call_trace.enabled()) {
       gpr_log(
           GPR_DEBUG,
-          "%s[connected] Tagging trailing metadata with "
-          "cancellation status from transport: %s",
-          Activity::current()->DebugTag().c_str(),
+          "%sTagging trailing metadata with cancellation status from "
+          "transport: %s",
+          batch->DebugPrefix().c_str(),
           actually_sent ? "sent => not-cancelled" : "not-sent => cancelled");
     }
     sent_metadata->Set(GrpcCallWasCancelled(), !actually_sent);

data/src/core/lib/transport/batch_builder.h

@@ -19,12 +19,14 @@
 
 #include <stdint.h>
 
+#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -202,6 +204,11 @@ class BatchBuilder {
     ~Batch();
     Batch(const Batch&) = delete;
     Batch& operator=(const Batch&) = delete;
+    std::string DebugPrefix(Activity* activity = Activity::current()) const {
+      return absl::StrFormat("%s[connected] [batch %p] ", activity->DebugTag(),
+                             this);
+    }
+
     void IncrementRefCount() { ++refs; }
     void Unref() {
       if (--refs == 0) party->arena()->DeletePooled(this);
@@ -222,8 +229,8 @@ class BatchBuilder {
       if (this->*field != nullptr) return this->*field;
       this->*field = party->arena()->NewPooled<T>(Ref());
       if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_DEBUG, "%s[connected] Add batch closure for %s @ %s",
-                Activity::current()->DebugTag().c_str(),
+        gpr_log(GPR_DEBUG, "%sAdd batch closure for %s @ %s",
+                DebugPrefix().c_str(),
                 std::string((this->*field)->name()).c_str(),
                 (this->*field)->on_done_closure.DebugString().c_str());
       }
@@ -273,8 +280,8 @@ class BatchBuilder {
   // Combine send status and server metadata into a final status to report back
   // to the containing call.
   static ServerMetadataHandle CompleteSendServerTrailingMetadata(
-      ServerMetadataHandle sent_metadata, absl::Status send_result,
-      bool actually_sent);
+      Batch* batch, ServerMetadataHandle sent_metadata,
+      absl::Status send_result, bool actually_sent);
 
   grpc_transport_stream_op_batch_payload* const payload_;
   absl::optional<Target> target_;
@@ -282,12 +289,11 @@ class BatchBuilder {
 };
 
 inline auto BatchBuilder::SendMessage(Target target, MessageHandle message) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue send message: %s",
-            Activity::current()->DebugTag().c_str(),
+    gpr_log(GPR_DEBUG, "%sQueue send message: %s", batch->DebugPrefix().c_str(),
             message->DebugString().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_sends);
   batch->batch.on_complete = &pc->on_done_closure;
   batch->batch.send_message = true;
@@ -299,11 +305,11 @@ inline auto BatchBuilder::SendMessage(Target target, MessageHandle message) {
 
 inline auto BatchBuilder::SendInitialMetadata(
     Target target, Arena::PoolPtr<grpc_metadata_batch> md) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue send initial metadata: %s",
-            Activity::current()->DebugTag().c_str(), md->DebugString().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue send initial metadata: %s",
+            batch->DebugPrefix().c_str(), md->DebugString().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_sends);
   batch->batch.on_complete = &pc->on_done_closure;
   batch->batch.send_initial_metadata = true;
@@ -318,11 +324,11 @@ inline auto BatchBuilder::SendClientInitialMetadata(
 }
 
 inline auto BatchBuilder::SendClientTrailingMetadata(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue send trailing metadata",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue send trailing metadata",
+            batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_sends);
   batch->batch.on_complete = &pc->on_done_closure;
   batch->batch.send_trailing_metadata = true;
@@ -342,13 +348,6 @@ inline auto BatchBuilder::SendServerInitialMetadata(
 inline auto BatchBuilder::SendServerTrailingMetadata(
     Target target, ServerMetadataHandle metadata,
     bool convert_to_cancellation) {
-  if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] %s: %s",
-            Activity::current()->DebugTag().c_str(),
-            convert_to_cancellation ? "Send trailing metadata as cancellation"
-                                    : "Queue send trailing metadata",
-            metadata->DebugString().c_str());
-  }
   Batch* batch;
   PendingSends* pc;
   if (convert_to_cancellation) {
@@ -368,14 +367,20 @@ inline auto BatchBuilder::SendServerTrailingMetadata(
     payload_->send_trailing_metadata.send_trailing_metadata = metadata.get();
     payload_->send_trailing_metadata.sent = &pc->trailing_metadata_sent;
   }
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "%s%s: %s", batch->DebugPrefix().c_str(),
+            convert_to_cancellation ? "Send trailing metadata as cancellation"
+                                    : "Queue send trailing metadata",
+            metadata->DebugString().c_str());
+  }
   batch->batch.on_complete = &pc->on_done_closure;
   pc->send_trailing_metadata = std::move(metadata);
-  auto promise = batch->RefUntil(
-      Map(pc->done_latch.WaitAndCopy(), [pc](absl::Status status) {
-        return CompleteSendServerTrailingMetadata(
-            std::move(pc->send_trailing_metadata), std::move(status),
-            pc->trailing_metadata_sent);
-      }));
+  auto promise = Map(pc->done_latch.WaitAndCopy(),
+                     [pc, batch = batch->Ref()](absl::Status status) {
+                       return CompleteSendServerTrailingMetadata(
+                           batch.get(), std::move(pc->send_trailing_metadata),
+                           std::move(status), pc->trailing_metadata_sent);
+                     });
   if (convert_to_cancellation) {
     batch->PerformWith(target);
   }
@@ -383,11 +388,10 @@ inline auto BatchBuilder::SendServerTrailingMetadata(
 }
 
 inline auto BatchBuilder::ReceiveMessage(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue receive message",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue receive message", batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(&Batch::pending_receive_message);
   batch->batch.recv_message = true;
   payload_->recv_message.recv_message_ready = &pc->on_done_closure;
@@ -411,11 +415,11 @@ inline auto BatchBuilder::ReceiveMessage(Target target) {
 }
 
 inline auto BatchBuilder::ReceiveInitialMetadata(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue receive initial metadata",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue receive initial metadata",
+            batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc =
       batch->GetInitializedCompletion(&Batch::pending_receive_initial_metadata);
   batch->batch.recv_initial_metadata = true;
@@ -439,11 +443,11 @@ inline auto BatchBuilder::ReceiveServerInitialMetadata(Target target) {
 }
 
 inline auto BatchBuilder::ReceiveTrailingMetadata(Target target) {
+  auto* batch = GetBatch(target);
   if (grpc_call_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[connected] Queue receive trailing metadata",
-            Activity::current()->DebugTag().c_str());
+    gpr_log(GPR_DEBUG, "%sQueue receive trailing metadata",
+            batch->DebugPrefix().c_str());
   }
-  auto* batch = GetBatch(target);
   auto* pc = batch->GetInitializedCompletion(
       &Batch::pending_receive_trailing_metadata);
   batch->batch.recv_trailing_metadata = true;

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -62,7 +62,6 @@ extern void RegisterPickFirstLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterRoundRobinLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterWeightedRoundRobinLbPolicy(
     CoreConfiguration::Builder* builder);
-extern void RegisterRingHashLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 #ifndef GRPC_NO_RLS
 extern void RegisterRlsLbPolicy(CoreConfiguration::Builder* builder);
@@ -85,7 +84,6 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterPickFirstLbPolicy(builder);
   RegisterRoundRobinLbPolicy(builder);
   RegisterWeightedRoundRobinLbPolicy(builder);
-  RegisterRingHashLbPolicy(builder);
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
   RegisterClientAuthorityFilter(builder);

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -39,6 +39,7 @@ extern void RegisterXdsClusterResolverLbPolicy(
 extern void RegisterXdsOverrideHostLbPolicy(
     CoreConfiguration::Builder* builder);
 extern void RegisterXdsWrrLocalityLbPolicy(CoreConfiguration::Builder* builder);
+extern void RegisterRingHashLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterFileWatcherCertificateProvider(
     CoreConfiguration::Builder* builder);
 #endif
@@ -60,6 +61,7 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   RegisterXdsClusterResolverLbPolicy(builder);
   RegisterXdsOverrideHostLbPolicy(builder);
   RegisterXdsWrrLocalityLbPolicy(builder);
+  RegisterRingHashLbPolicy(builder);
   RegisterFileWatcherCertificateProvider(builder);
 #endif
 }

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

@@ -34,24 +34,23 @@ def env_unset?(name)
   ENV[name].nil? || ENV[name].size == 0
 end
 
-def rbconfig_set?(name)
-  RbConfig::CONFIG[name] && RbConfig::CONFIG[name].size > 0
+def inherit_env_or_rbconfig(name)
+  ENV[name] = inherit_rbconfig(name) if env_unset?(name)
 end
 
 def inherit_rbconfig(name)
-  ENV[name] = RbConfig::CONFIG[name] if env_unset?(name) && rbconfig_set?(name)
+  ENV[name] = RbConfig::CONFIG[name] || ''
 end
 
 def env_append(name, string)
-  ENV[name] ||= ''
   ENV[name] += ' ' + string
 end
 
-inherit_rbconfig 'AR'
-inherit_rbconfig 'CC'
-inherit_rbconfig 'CXX'
-inherit_rbconfig 'RANLIB'
-inherit_rbconfig 'STRIP'
+inherit_env_or_rbconfig 'AR'
+inherit_env_or_rbconfig 'CC'
+inherit_env_or_rbconfig 'CXX'
+inherit_env_or_rbconfig 'RANLIB'
+inherit_env_or_rbconfig 'STRIP'
 inherit_rbconfig 'CPPFLAGS'
 inherit_rbconfig 'LDFLAGS'
 

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.55.0'
+  VERSION = '1.56.0.pre3'
 end

data/third_party/boringssl-with-bazel/src/crypto/asn1/a_mbstr.c

@@ -73,18 +73,19 @@
 // horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
 // size limits too.
 
-int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
-                       int inform, unsigned long mask) {
-  return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0);
+int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in,
+                       ossl_ssize_t len, int inform, unsigned long mask) {
+  return ASN1_mbstring_ncopy(out, in, len, inform, mask, /*minsize=*/0,
+                             /*maxsize=*/0);
 }
 
 OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_BMPSTRING)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UNIVERSALSTRING)
 OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UTF8STRING)
 
-int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
-                        int inform, unsigned long mask, long minsize,
-                        long maxsize) {
+int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in,
+                        ossl_ssize_t len, int inform, unsigned long mask,
+                        ossl_ssize_t minsize, ossl_ssize_t maxsize) {
   if (len == -1) {
     len = strlen((const char *)in);
   }
@@ -164,14 +165,14 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
     utf8_len += cbb_get_utf8_len(c);
     if (maxsize > 0 && nchar > (size_t)maxsize) {
       OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_LONG);
-      ERR_add_error_dataf("maxsize=%ld", maxsize);
+      ERR_add_error_dataf("maxsize=%zu", (size_t)maxsize);
       return -1;
     }
   }
 
   if (minsize > 0 && nchar < (size_t)minsize) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT);
-    ERR_add_error_dataf("minsize=%ld", minsize);
+    ERR_add_error_dataf("minsize=%zu", (size_t)minsize);
     return -1;
   }
 

data/third_party/boringssl-with-bazel/src/crypto/asn1/a_strnid.c

@@ -87,7 +87,7 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid);
 // a corresponding OID. For example certificates and certificate requests.
 
 ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in,
-                                    int len, int inform, int nid) {
+                                    ossl_ssize_t len, int inform, int nid) {
   ASN1_STRING *str = NULL;
   int ret;
   if (!out) {

data/third_party/boringssl-with-bazel/src/crypto/asn1/internal.h

@@ -56,8 +56,8 @@
  *
  */
 
-#ifndef OPENSSL_HEADER_ASN1_ASN1_LOCL_H
-#define OPENSSL_HEADER_ASN1_ASN1_LOCL_H
+#ifndef OPENSSL_HEADER_ASN1_INTERNAL_H
+#define OPENSSL_HEADER_ASN1_INTERNAL_H
 
 #include <time.h>
 
@@ -266,4 +266,4 @@ typedef struct ASN1_EXTERN_FUNCS_st {
 }  // extern C
 #endif
 
-#endif  // OPENSSL_HEADER_ASN1_ASN1_LOCL_H
+#endif  // OPENSSL_HEADER_ASN1_INTERNAL_H

data/third_party/boringssl-with-bazel/src/crypto/asn1/tasn_dec.c

@@ -85,7 +85,7 @@ static int asn1_template_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
 static int asn1_template_noexp_d2i(ASN1_VALUE **val, const unsigned char **in,
                                    long len, const ASN1_TEMPLATE *tt, char opt,
                                    CRYPTO_BUFFER *buf, int depth);
-static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
+static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len,
                        int utype, const ASN1_ITEM *it);
 static int asn1_d2i_ex_primitive(ASN1_VALUE **pval, const unsigned char **in,
                                  long len, const ASN1_ITEM *it, int tag,
@@ -749,7 +749,7 @@ err:
 
 // Translate ASN1 content octets into a structure
 
-static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
+static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len,
                        int utype, const ASN1_ITEM *it) {
   ASN1_VALUE **opval = NULL;
   ASN1_STRING *stmp;
@@ -837,7 +837,14 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
     case V_ASN1_UTF8STRING:
     case V_ASN1_OTHER:
     case V_ASN1_SET:
-    case V_ASN1_SEQUENCE: {
+    case V_ASN1_SEQUENCE:
+    // TODO(crbug.com/boringssl/412): This default case should be removed, now
+    // that we've resolved https://crbug.com/boringssl/561. However, it is still
+    // needed to support some edge cases in |ASN1_PRINTABLE|. |ASN1_PRINTABLE|
+    // broadly doesn't tolerate unrecognized universal tags, but except for
+    // eight values that map to |B_ASN1_UNKNOWN| instead of zero. See the
+    // X509Test.NameAttributeValues test.
+    default: {
       CBS cbs;
       CBS_init(&cbs, cont, (size_t)len);
       if (utype == V_ASN1_BMPSTRING) {
@@ -900,9 +907,6 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
       }
       break;
     }
-    default:
-      OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
-      goto err;
   }
   // If ASN1_ANY and NULL type fix up value
   if (typ && (utype == V_ASN1_NULL)) {