grpc 1.75.0 → 1.78.0

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

@@ -23,8 +23,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/extensions/filters/http/stateful_session/v3/stateful_session.upb.h"
 #include "envoy/extensions/filters/http/stateful_session/v3/stateful_session.upbdefs.h"
@@ -42,6 +40,8 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -198,7 +198,7 @@ XdsHttpStatefulSessionFilter::GenerateFilterConfigOverride(
 
 void XdsHttpStatefulSessionFilter::AddFilter(
     InterceptionChainBuilder& builder) const {
-  builder.Add<StatefulSessionFilter>();
+  builder.Add<StatefulSessionFilter>(nullptr);
 }
 
 const grpc_channel_filter* XdsHttpStatefulSessionFilter::channel_filter()

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

@@ -21,8 +21,6 @@
 
 #include <optional>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/validation_errors.h"
@@ -30,6 +28,8 @@
 #include "src/core/xds/grpc/xds_http_filter.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "upb/reflection/def.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

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

@@ -26,7 +26,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/strings/str_cat.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.upb.h"
 #include "envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.upb.h"
@@ -39,6 +38,7 @@
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 

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

@@ -22,11 +22,11 @@
 #include <map>
 #include <memory>
 
-#include "absl/strings/string_view.h"
 #include "envoy/config/cluster/v3/cluster.upb.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

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

@@ -16,11 +16,11 @@
 
 #include "src/core/xds/grpc/xds_listener.h"
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/util/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/util/match.h"
 
 namespace grpc_core {
 

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

@@ -21,13 +21,6 @@
 #include <set>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/config_source.upb.h"
@@ -48,6 +41,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/util/down_cast.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/match.h"
 #include "src/core/util/upb_utils.h"
@@ -57,6 +51,12 @@
 #include "src/core/xds/grpc/xds_route_config_parser.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "upb/text/encode.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 
 namespace grpc_core {
 
@@ -739,8 +739,8 @@ void AddFilterChainDataForSourceType(
     const FilterChain& filter_chain,
     InternalFilterChainMap::DestinationIp* destination_ip,
     ValidationErrors* errors) {
-  CHECK(static_cast<unsigned int>(filter_chain.filter_chain_match.source_type) <
-        3u);
+  GRPC_CHECK(static_cast<unsigned int>(
+                 filter_chain.filter_chain_match.source_type) < 3u);
   AddFilterChainDataForSourceIpRange(
       filter_chain,
       &destination_ip->source_types_array[static_cast<int>(

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

@@ -17,7 +17,6 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_LISTENER_PARSER_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_LISTENER_PARSER_H
 
-#include "absl/strings/string_view.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
 #include "src/core/util/down_cast.h"
@@ -28,6 +27,7 @@
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "src/core/xds/xds_client/xds_resource_type_impl.h"
 #include "upb/reflection/def.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

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

@@ -0,0 +1,277 @@
+//
+// Copyright 2025 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/xds_matcher.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "src/core/util/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+
+namespace grpc_core {
+
+//
+// XdsMatcher
+//
+
+bool XdsMatcher::OnMatch::operator==(const OnMatch& other) const {
+  if (keep_matching != other.keep_matching) return false;
+  if (action.index() != other.action.index()) return false;
+  return Match(
+      action,
+      [&](const std::unique_ptr<Action>& action) {
+        const auto& other_action =
+            std::get<std::unique_ptr<Action>>(other.action);
+        if (action == nullptr) return other_action == nullptr;
+        if (other_action == nullptr) return false;
+        return action->Equals(*other_action);
+      },
+      [&](const std::unique_ptr<XdsMatcher>& matcher) {
+        const auto& other_matcher =
+            std::get<std::unique_ptr<XdsMatcher>>(other.action);
+        if (matcher == nullptr) return other_matcher == nullptr;
+        if (other_matcher == nullptr) return false;
+        return matcher->Equals(*other_matcher);
+      });
+}
+
+std::string XdsMatcher::OnMatch::ToString() const {
+  std::vector<std::string> parts;
+  parts.push_back(Match(
+      action,
+      [](const std::unique_ptr<Action>& action) {
+        return absl::StrCat("action=", action->ToString());
+      },
+      [](const std::unique_ptr<XdsMatcher>& matcher) {
+        return absl::StrCat("matcher=", matcher->ToString());
+      }));
+  parts.push_back(
+      absl::StrCat("keep_matching=", keep_matching ? "true" : "false"));
+  return absl::StrCat("{", absl::StrJoin(parts, ", "), "}");
+}
+
+bool XdsMatcher::OnMatch::FindMatches(const MatchContext& context,
+                                      Result& result) const {
+  // Confusingly, this Match() call has nothing to do with the
+  // matching we're doing here -- it's the name of our utility
+  // method for accessing fields of std::variant<>.
+  return Match(
+      action,
+      [&](const std::unique_ptr<Action>& action) {
+        result.push_back(action.get());
+        return !keep_matching;
+      },
+      [&](const std::unique_ptr<XdsMatcher>& matcher) {
+        return matcher->FindMatches(context, result) && !keep_matching;
+      });
+}
+
+//
+// XdsMatcherList
+//
+
+bool XdsMatcherList::Equals(const XdsMatcher& other) const {
+  if (type() != other.type()) return false;
+  const auto& o = DownCast<const XdsMatcherList&>(other);
+  if (matchers_.size() != o.matchers_.size()) return false;
+  for (size_t i = 0; i < matchers_.size(); ++i) {
+    if (matchers_[i] != o.matchers_[i]) return false;
+  }
+  return on_no_match_ == o.on_no_match_;
+}
+
+std::string XdsMatcherList::ToString() const {
+  std::vector<std::string> parts;
+  for (const auto& matcher : matchers_) {
+    parts.push_back(matcher.ToString());
+  }
+  if (on_no_match_.has_value()) {
+    parts.push_back(absl::StrCat("on_no_match=", on_no_match_->ToString()));
+  }
+  return absl::StrCat("XdsMatcherList{", absl::StrJoin(parts, ", "), "}");
+}
+
+bool XdsMatcherList::FindMatches(const MatchContext& context,
+                                 Result& result) const {
+  for (const auto& [predicate, on_match] : matchers_) {
+    if (predicate->Match(context)) {
+      if (on_match.FindMatches(context, result)) return true;
+    }
+  }
+  if (on_no_match_.has_value()) {
+    if (on_no_match_->FindMatches(context, result)) return true;
+  }
+  return false;
+}
+
+bool XdsMatcherList::AndPredicate::Equals(const Predicate& other) const {
+  if (type() != other.type()) return false;
+  const auto& o = DownCast<const AndPredicate&>(other);
+  if (predicates_.size() != o.predicates_.size()) return false;
+  for (size_t i = 0; i < predicates_.size(); ++i) {
+    if (!predicates_[i]->Equals(*o.predicates_[i])) return false;
+  }
+  return true;
+}
+
+std::string XdsMatcherList::AndPredicate::ToString() const {
+  std::vector<std::string> parts;
+  for (const auto& predicate : predicates_) {
+    parts.push_back(predicate->ToString());
+  }
+  return absl::StrCat("And{", absl::StrJoin(parts, ", "), "}");
+}
+
+bool XdsMatcherList::AndPredicate::Match(
+    const XdsMatcher::MatchContext& context) const {
+  for (const auto& predicate : predicates_) {
+    if (!predicate->Match(context)) return false;
+  }
+  return true;
+}
+
+bool XdsMatcherList::OrPredicate::Equals(const Predicate& other) const {
+  if (type() != other.type()) return false;
+  const auto& o = DownCast<const OrPredicate&>(other);
+  if (predicates_.size() != o.predicates_.size()) return false;
+  for (size_t i = 0; i < predicates_.size(); ++i) {
+    if (!predicates_[i]->Equals(*o.predicates_[i])) return false;
+  }
+  return true;
+}
+
+std::string XdsMatcherList::OrPredicate::ToString() const {
+  std::vector<std::string> parts;
+  for (const auto& predicate : predicates_) {
+    parts.push_back(predicate->ToString());
+  }
+  return absl::StrCat("Or{", absl::StrJoin(parts, ", "), "}");
+}
+
+bool XdsMatcherList::OrPredicate::Match(
+    const XdsMatcher::MatchContext& context) const {
+  for (const auto& predicate : predicates_) {
+    if (predicate->Match(context)) return true;
+  }
+  return false;
+}
+
+//
+// XdsMatcherExactMap
+//
+
+bool XdsMatcherExactMap::Equals(const XdsMatcher& other) const {
+  if (type() != other.type()) return false;
+  const auto& o = DownCast<const XdsMatcherExactMap&>(other);
+  if (!input_->Equals(*o.input_)) return false;
+  if (map_ != o.map_) return false;
+  return on_no_match_ == o.on_no_match_;
+}
+
+std::string XdsMatcherExactMap::ToString() const {
+  std::vector<std::string> map_parts;
+  for (const auto& pair : map_) {
+    map_parts.push_back(
+        absl::StrCat("{\"", pair.first, "\": ", pair.second.ToString(), "}"));
+  }
+  std::sort(map_parts.begin(), map_parts.end());
+  std::vector<std::string> parts;
+  parts.push_back(absl::StrCat("input=", input_->ToString()));
+  parts.push_back(absl::StrCat("map={", absl::StrJoin(map_parts, ", "), "}"));
+  if (on_no_match_.has_value()) {
+    parts.push_back(absl::StrCat("on_no_match=", on_no_match_->ToString()));
+  }
+  return absl::StrCat("XdsMatcherExactMap{", absl::StrJoin(parts, ", "), "}");
+}
+
+bool XdsMatcherExactMap::FindMatches(const MatchContext& context,
+                                     Result& result) const {
+  auto input = input_->GetValue(context);
+  auto it = map_.find(input.value_or(""));
+  if (it != map_.end()) {
+    if (it->second.FindMatches(context, result)) return true;
+  }
+  if (on_no_match_.has_value()) {
+    if (on_no_match_->FindMatches(context, result)) return true;
+  }
+  return false;
+}
+
+//
+// XdsMatcherPrefixMap
+//
+
+XdsMatcherPrefixMap::XdsMatcherPrefixMap(
+    std::unique_ptr<InputValue<absl::string_view>> input,
+    absl::flat_hash_map<std::string, XdsMatcher::OnMatch> map,
+    std::optional<OnMatch> on_no_match)
+    : input_(std::move(input)), on_no_match_(std::move(on_no_match)) {
+  for (auto& [key, value] : map) {
+    root_.AddNode(key, std::move(value));
+  }
+}
+
+bool XdsMatcherPrefixMap::Equals(const XdsMatcher& other) const {
+  if (type() != other.type()) return false;
+  const auto& o = DownCast<const XdsMatcherPrefixMap&>(other);
+  if (!input_->Equals(*o.input_)) return false;
+  if (root_ != o.root_) return false;
+  return on_no_match_ == o.on_no_match_;
+}
+
+std::string XdsMatcherPrefixMap::ToString() const {
+  std::vector<std::string> map_parts;
+  root_.ForEach([&](absl::string_view key, const OnMatch& value) {
+    map_parts.push_back(
+        absl::StrCat("{\"", key, "\": ", value.ToString(), "}"));
+  });
+  std::sort(map_parts.begin(), map_parts.end());
+  std::vector<std::string> parts;
+  parts.push_back(absl::StrCat("input=", input_->ToString()));
+  parts.push_back(absl::StrCat("map={", absl::StrJoin(map_parts, ", "), "}"));
+  if (on_no_match_.has_value()) {
+    parts.push_back(absl::StrCat("on_no_match=", on_no_match_->ToString()));
+  }
+  return absl::StrCat("XdsMatcherPrefixMap{", absl::StrJoin(parts, ", "), "}");
+}
+
+bool XdsMatcherPrefixMap::FindMatches(const MatchContext& context,
+                                      Result& result) const {
+  auto input = input_->GetValue(context);
+  std::vector<const OnMatch*> on_match_results;
+  root_.ForEachPrefixMatch(input.value_or(""), [&](const OnMatch& on_match) {
+    if (!on_match.keep_matching) {
+      // Don't need previous entries if we can use this one.
+      on_match_results.clear();
+    }
+    on_match_results.push_back(&on_match);
+  });
+  for (auto it = on_match_results.rbegin(); it != on_match_results.rend();
+       ++it) {
+    if ((*it)->FindMatches(context, result)) {
+      return true;
+    }
+  }
+  if (on_no_match_.has_value()) {
+    if (on_no_match_->FindMatches(context, result)) return true;
+  }
+  return false;
+}
+
+}  // namespace grpc_core