grpc 1.65.1 → 1.66.0.pre3

data/src/core/client_channel/lb_metadata.h

@@ -0,0 +1,56 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_LB_METADATA_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_LB_METADATA_H
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/slice.h>
+
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/load_balancing/lb_policy.h"
+
+namespace grpc_core {
+
+class LbMetadata : public LoadBalancingPolicy::MetadataInterface {
+ public:
+  explicit LbMetadata(grpc_metadata_batch* batch) : batch_(batch) {}
+
+  absl::optional<absl::string_view> Lookup(absl::string_view key,
+                                           std::string* buffer) const override;
+
+  std::vector<std::pair<std::string, std::string>> TestOnlyCopyToVector() const;
+
+ private:
+  grpc_metadata_batch* batch_;
+};
+
+class MetadataMutationHandler {
+ public:
+  static void Apply(LoadBalancingPolicy::MetadataMutations& metadata_mutations,
+                    grpc_metadata_batch* metadata);
+};
+
+void MaybeOverrideAuthority(
+    grpc_event_engine::experimental::Slice authority_override,
+    grpc_metadata_batch* metadata);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_LB_METADATA_H

data/src/core/client_channel/load_balanced_call_destination.cc

@@ -14,8 +14,11 @@
 
 #include "src/core/client_channel/load_balanced_call_destination.h"
 
+#include "absl/log/log.h"
+
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/client_channel/client_channel_internal.h"
+#include "src/core/client_channel/lb_metadata.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -26,76 +29,6 @@ namespace grpc_core {
 
 namespace {
 
-class LbMetadata : public LoadBalancingPolicy::MetadataInterface {
- public:
-  explicit LbMetadata(grpc_metadata_batch* batch) : batch_(batch) {}
-
-  void Add(absl::string_view key, absl::string_view value) override {
-    if (batch_ == nullptr) return;
-    // Gross, egregious hack to support legacy grpclb behavior.
-    // TODO(ctiller): Use a promise context for this once that plumbing is done.
-    if (key == GrpcLbClientStatsMetadata::key()) {
-      batch_->Set(
-          GrpcLbClientStatsMetadata(),
-          const_cast<GrpcLbClientStats*>(
-              reinterpret_cast<const GrpcLbClientStats*>(value.data())));
-      return;
-    }
-    batch_->Append(key, Slice::FromStaticString(value),
-                   [key](absl::string_view error, const Slice& value) {
-                     gpr_log(GPR_ERROR, "%s",
-                             absl::StrCat(error, " key:", key,
-                                          " value:", value.as_string_view())
-                                 .c_str());
-                   });
-  }
-
-  std::vector<std::pair<std::string, std::string>> TestOnlyCopyToVector()
-      override {
-    if (batch_ == nullptr) return {};
-    Encoder encoder;
-    batch_->Encode(&encoder);
-    return encoder.Take();
-  }
-
-  absl::optional<absl::string_view> Lookup(absl::string_view key,
-                                           std::string* buffer) const override {
-    if (batch_ == nullptr) return absl::nullopt;
-    return batch_->GetStringValue(key, buffer);
-  }
-
- private:
-  class Encoder {
-   public:
-    void Encode(const Slice& key, const Slice& value) {
-      out_.emplace_back(std::string(key.as_string_view()),
-                        std::string(value.as_string_view()));
-    }
-
-    template <class Which>
-    void Encode(Which, const typename Which::ValueType& value) {
-      auto value_slice = Which::Encode(value);
-      out_.emplace_back(std::string(Which::key()),
-                        std::string(value_slice.as_string_view()));
-    }
-
-    void Encode(GrpcTimeoutMetadata,
-                const typename GrpcTimeoutMetadata::ValueType&) {}
-    void Encode(HttpPathMetadata, const Slice&) {}
-    void Encode(HttpMethodMetadata,
-                const typename HttpMethodMetadata::ValueType&) {}
-
-    std::vector<std::pair<std::string, std::string>> Take() {
-      return std::move(out_);
-    }
-
-   private:
-    std::vector<std::pair<std::string, std::string>> out_;
-  };
-
-  grpc_metadata_batch* batch_;
-};
-
 void MaybeCreateCallAttemptTracer(bool is_transparent_retry) {
   auto* call_tracer = MaybeGetContext<ClientCallTracer>();
   if (call_tracer == nullptr) return;
@@ -208,6 +141,11 @@ LoopCtl<absl::StatusOr<RefCountedPtr<UnstartedCallDestination>>> PickSubchannel(
           complete_pick->subchannel_call_tracker->Start();
           SetContext(complete_pick->subchannel_call_tracker.release());
         }
+        // Apply metadata mutations, if any.
+        MetadataMutationHandler::Apply(complete_pick->metadata_mutations,
+                                       &client_initial_metadata);
+        MaybeOverrideAuthority(std::move(complete_pick->authority_override),
+                               &client_initial_metadata);
         // Return the connected subchannel.
         return call_destination;
       },

data/src/core/client_channel/retry_filter.cc

@@ -147,7 +147,7 @@ const grpc_channel_filter RetryFilter::kVtable = {
     grpc_channel_stack_no_post_init,
     RetryFilter::Destroy,
     RetryFilter::GetChannelInfo,
-    "retry_filter",
+    GRPC_UNIQUE_TYPE_NAME_HERE("retry_filter"),
 };
 
 }  // namespace grpc_core