grpc 1.81.1 → 1.83.0

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

@@ -0,0 +1,58 @@
+//
+// 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.
+//
+
+#include "src/core/xds/grpc/blackboard.h"
+
+namespace grpc_core {
+
+void Blackboard::Entry::Orphaned() {
+  if (blackboard_ != nullptr) blackboard_->Remove(type_, key_, this);
+}
+
+RefCountedPtr<Blackboard::Entry> Blackboard::Get(UniqueTypeName type,
+                                                 const std::string& key) const {
+  MutexLock lock(&mu_);
+  auto it = map_.find(std::pair(type, key));
+  if (it == map_.end()) return nullptr;
+  return it->second->RefIfNonZero();
+}
+
+RefCountedPtr<Blackboard::Entry> Blackboard::GetOrSet(
+    UniqueTypeName type, const std::string& key,
+    absl::FunctionRef<RefCountedPtr<Entry>()> construct) {
+  MutexLock lock(&mu_);
+  auto& entry = map_[std::pair(type, key)];
+  if (entry != nullptr) {
+    auto reffed_entry = entry->RefIfNonZero();
+    if (reffed_entry != nullptr) return reffed_entry;
+  }
+  auto constructed = construct();
+  entry = constructed->WeakRef();
+  constructed->blackboard_ = Ref();
+  constructed->type_ = type;
+  constructed->key_ = key;
+  return constructed;
+}
+
+void Blackboard::Remove(UniqueTypeName type, const std::string& key,
+                        Entry* entry) {
+  MutexLock lock(&mu_);
+  auto it = map_.find(std::pair(type, key));
+  if (it == map_.end()) return;
+  if (it->second == entry) map_.erase(it);
+}
+
+}  // namespace grpc_core

data/src/core/{filter → xds/grpc}/blackboard.h

@@ -14,19 +14,22 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_FILTER_BLACKBOARD_H
-#define GRPC_SRC_CORE_FILTER_BLACKBOARD_H
+#ifndef GRPC_SRC_CORE_XDS_GRPC_BLACKBOARD_H
+#define GRPC_SRC_CORE_XDS_GRPC_BLACKBOARD_H
 
 #include <string>
 #include <utility>
 
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/dual_ref_counted.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/useful.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/functional/function_ref.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
@@ -41,7 +44,17 @@ class Blackboard : public RefCounted<Blackboard> {
   // All entries must derive from this type.
   // They must also have a static method with the following signature:
   //  static UniqueTypeName Type();
-  class Entry : public RefCounted<Entry> {};
+  class Entry : public DualRefCounted<Entry> {
+   public:
+    void Orphaned() final;
+
+   private:
+    friend class Blackboard;
+
+    RefCountedPtr<Blackboard> blackboard_;
+    UniqueTypeName type_{GRPC_UNIQUE_TYPE_NAME_HERE("")};
+    std::string key_;
+  };
 
   // Returns an entry for a particular type and name, or null if not present.
   template <typename T>
@@ -49,22 +62,28 @@ class Blackboard : public RefCounted<Blackboard> {
     return Get(T::Type(), key).template TakeAsSubclass<T>();
   }
 
-  // Sets an entry for a particular type and name.
+  // Gets the entry for the specified key.  If not present, invokes
+  // construct to create it.  Returns the entry.
   template <typename T>
-  void Set(const std::string& key, RefCountedPtr<T> entry) {
-    Set(T::Type(), key, std::move(entry));
+  RefCountedPtr<T> GetOrSet(const std::string& key,
+                            absl::FunctionRef<RefCountedPtr<T>()> construct) {
+    return GetOrSet(T::Type(), key, std::move(construct))
+        .template TakeAsSubclass<T>();
   }
 
  private:
   RefCountedPtr<Entry> Get(UniqueTypeName type, const std::string& key) const;
-  void Set(UniqueTypeName type, const std::string& key,
-           RefCountedPtr<Entry> entry);
+  RefCountedPtr<Entry> GetOrSet(
+      UniqueTypeName type, const std::string& key,
+      absl::FunctionRef<RefCountedPtr<Entry>()> construct);
+  void Remove(UniqueTypeName type, const std::string& key, Entry* entry);
 
+  mutable Mutex mu_;
   absl::flat_hash_map<std::pair<UniqueTypeName, std::string>,
-                      RefCountedPtr<Entry>>
-      map_;
+                      WeakRefCountedPtr<Entry>>
+      map_ ABSL_GUARDED_BY(&mu_);
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_FILTER_BLACKBOARD_H
+#endif  // GRPC_SRC_CORE_XDS_GRPC_BLACKBOARD_H

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

@@ -26,10 +26,9 @@
 #include <vector>
 
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/credentials/transport/tls/grpc_tls_certificate_provider.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
-#include "src/core/util/string.h"
 #include "absl/log/log.h"
 
 namespace grpc_core {
@@ -38,14 +37,6 @@ namespace {
 
 constexpr absl::string_view kFileWatcherPlugin = "file_watcher";
 
-bool SpiffeBundleMapEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_MTLS_SPIFFE");
-  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
 
 //
@@ -115,7 +106,7 @@ void FileWatcherCertificateProviderFactory::Config::JsonPostLoad(
         "fields \"certificate_file\" and \"private_key_file\" must be both set "
         "or both unset");
   }
-  if (SpiffeBundleMapEnabled()) {
+  if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_MTLS_SPIFFE")) {
     if (json.object().find("certificate_file") == json.object().end() &&
         json.object().find("ca_certificate_file") == json.object().end() &&
         json.object().find("spiffe_bundle_map_file") == json.object().end()) {

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

@@ -24,14 +24,13 @@
 #include <utility>
 #include <vector>
 
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/string.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
@@ -42,11 +41,7 @@ namespace grpc_core {
 
 // TODO(roth): Remove this once the feature passes interop tests.
 bool XdsExtProcOnClientEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_EXT_PROC_ON_CLIENT");
-  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;
+  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_EXT_PROC_ON_CLIENT");
 }
 
 //

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

@@ -40,10 +40,10 @@
 #include "google/protobuf/struct.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/time.h"
@@ -68,24 +68,11 @@ namespace grpc_core {
 
 // TODO(roth): Remove this once the feature passes interop tests.
 bool XdsHttpConnectEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_HTTP_CONNECT");
-  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;
+  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_HTTP_CONNECT");
 }
 
 namespace {
 
-// TODO(mlumish): Remove this after the 1.81 release.
-bool XdsSniEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_SNI");
-  if (!value.has_value()) return true;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 constexpr absl::string_view kUpstreamTlsContextType =
     "envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext";
 
@@ -111,7 +98,9 @@ XdsClusterResource::UpstreamTlsContext UpstreamTlsContextParse(
     errors->AddError("can't decode UpstreamTlsContext");
     return {};
   }
-  if (XdsSniEnabled()) {
+  // TODO(mlumish): Remove this conditional after the 1.81 release.
+  if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_SNI",
+                                /*default_value=*/true)) {
     upstream_tls_context.sni = UpbStringToStdString(
         envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_sni(
             upstream_tls_context_proto));

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

@@ -16,9 +16,17 @@
 
 #include "src/core/xds/grpc/xds_common_types.h"
 
+#include <string>
+#include <utility>
+
+#include "src/core/call/metadata_batch.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/util/match.h"
 #include "src/core/util/string.h"
+#include "absl/status/status.h"
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -170,4 +178,92 @@ std::string HeaderMutationRules::ToString() const {
   return result;
 }
 
+//
+// XdsHeaderValueOption
+//
+
+namespace {
+
+void ApplyHeaderValueOptionMutation(const XdsHeaderValueOption& header,
+                                    grpc_metadata_batch& md) {
+  auto& [header_key, header_value] = header.header;
+  std::string buffer;
+  auto existing_value = md.GetStringValue(header_key, &buffer);
+  switch (header.append_action) {
+    case XdsHeaderValueOption::AppendAction::kAppendIfExistsOrAdd: {
+      if (!existing_value.has_value()) {
+        md.Append(header_key, Slice::FromCopiedString(header_value),
+                  [](absl::string_view, const Slice&) {});
+      } else if (!header_value.empty()) {
+        std::string concatenated_val =
+            absl::StrCat(*existing_value, ",", header_value);
+        md.Remove(absl::string_view(header_key));
+        md.Append(header_key,
+                  Slice::FromCopiedString(std::move(concatenated_val)),
+                  [](absl::string_view, const Slice&) {});
+      }
+      break;
+    }
+    case XdsHeaderValueOption::AppendAction::kAddIfAbsent: {
+      if (!existing_value.has_value()) {
+        md.Append(header_key, Slice::FromCopiedString(header_value),
+                  [](absl::string_view, const Slice&) {});
+      }
+      break;
+    }
+    case XdsHeaderValueOption::AppendAction::kOverwriteIfExists: {
+      if (existing_value.has_value()) {
+        md.Remove(absl::string_view(header_key));
+        md.Append(header_key, Slice::FromCopiedString(header_value),
+                  [](absl::string_view, const Slice&) {});
+      }
+      break;
+    }
+    case XdsHeaderValueOption::AppendAction::kOverwriteIfExistsOrAdd: {
+      md.Remove(absl::string_view(header_key));
+      md.Append(header_key, Slice::FromCopiedString(header_value),
+                [](absl::string_view, const Slice&) {});
+      break;
+    }
+  }
+}
+
+}  // namespace
+
+absl::Status ApplyXdsHeaderMutationsRemoval(absl::string_view remove_header,
+                                            const HeaderMutationRules* rules,
+                                            grpc_metadata_batch& md) {
+  bool allowed = true;
+  bool disallow_is_error = false;
+  if (rules != nullptr) {
+    allowed = rules->IsMutationAllowed(std::string(remove_header));
+    disallow_is_error = rules->disallow_is_error;
+  }
+  if (allowed) {
+    md.Remove(absl::string_view(remove_header));
+  } else if (disallow_is_error) {
+    return absl::InternalError(
+        absl::StrCat("Forbidden header removal: ", remove_header));
+  }
+  return absl::OkStatus();
+}
+
+absl::Status ApplyXdsHeaderMutationsAddition(
+    const XdsHeaderValueOption& set_header, const HeaderMutationRules* rules,
+    grpc_metadata_batch& md) {
+  bool allowed = true;
+  bool disallow_is_error = false;
+  if (rules != nullptr) {
+    allowed = rules->IsMutationAllowed(std::string(set_header.header.first));
+    disallow_is_error = rules->disallow_is_error;
+  }
+  if (allowed) {
+    ApplyHeaderValueOptionMutation(set_header, md);
+  } else if (disallow_is_error) {
+    return absl::InternalError(
+        absl::StrCat("Forbidden header mutation: ", set_header.header.first));
+  }
+  return absl::OkStatus();
+}
+
 }  // namespace grpc_core

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

@@ -17,14 +17,17 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_H
 
+#include <memory>
 #include <string>
+#include <utility>
 #include <variant>
 #include <vector>
 
+#include "src/core/call/metadata_batch.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/matchers.h"
 #include "src/core/util/validation_errors.h"
-#include "src/core/xds/grpc/xds_server_grpc.h"
+#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
@@ -86,12 +89,6 @@ struct XdsExtension {
   std::vector<ValidationErrors::ScopedField> validation_fields;
 };
 
-struct XdsGrpcService {
-  std::unique_ptr<GrpcXdsServerTarget> server_target;
-  Duration timeout;
-  std::vector<std::pair<std::string, std::string>> initial_metadata;
-};
-
 struct HeaderMutationRules {
   bool disallow_all = false;
   bool disallow_is_error = false;
@@ -116,6 +113,37 @@ struct HeaderMutationRules {
   }
 };
 
+struct XdsHeaderValueOption {
+  enum class AppendAction {
+    // If the header already exists in the metadata batch, comma-concatenate the
+    // new value.
+    // Otherwise, append a new metadata entry.
+    kAppendIfExistsOrAdd = 0,
+    // Add the header only if it is not currently present in the metadata batch.
+    kAddIfAbsent = 1,
+    // Discard any existing entries in the metadata batch and append the new
+    // value.
+    kOverwriteIfExistsOrAdd = 2,
+    // If the header already exists, discard existing entries and replace with
+    // the new value.
+    // If absent, do nothing.
+    kOverwriteIfExists = 3
+  };
+
+  // The targeted metadata key and value to apply during mutation.
+  std::pair<std::string, std::string> header;
+  // Rule specifying how to merge or overwrite existing metadata batch entries.
+  AppendAction append_action;
+};
+
+absl::Status ApplyXdsHeaderMutationsRemoval(absl::string_view remove_header,
+                                            const HeaderMutationRules* rules,
+                                            grpc_metadata_batch& md);
+
+absl::Status ApplyXdsHeaderMutationsAddition(
+    const XdsHeaderValueOption& set_header, const HeaderMutationRules* rules,
+    grpc_metadata_batch& md);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_H