grpc 1.47.0 → 1.48.0.pre1

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

@@ -0,0 +1,291 @@
+//
+// Copyright 2022 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 <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/xds_lb_policy_registry.h"
+
+#include <stddef.h>
+
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "envoy/config/core/v3/extension.upb.h"
+#include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
+#include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
+#include "google/protobuf/any.upb.h"
+#include "google/protobuf/struct.upb.h"
+#include "google/protobuf/struct.upbdefs.h"
+#include "google/protobuf/wrappers.upb.h"
+#include "upb/json_encode.h"
+#include "upb/upb.h"
+#include "upb/upb.hpp"
+#include "xds/type/v3/typed_struct.upb.h"
+
+#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/lib/iomgr/error.h"
+
+namespace grpc_core {
+
+namespace {
+
+class RingHashLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+      const XdsEncodingContext& context, absl::string_view configuration,
+      int /* recursion_depth */) override {
+    const auto* resource =
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_parse(
+            configuration.data(), configuration.size(), context.arena);
+    if (resource == nullptr) {
+      return absl::InvalidArgumentError(
+          "Can't decode RingHash loadbalancing policy");
+    }
+    if (envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_hash_function(
+            resource) !=
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_XX_HASH) {
+      return absl::InvalidArgumentError(
+          "Invalid hash function provided for RingHash loadbalancing policy. "
+          "Only XX_HASH is supported.");
+    }
+    Json::Object json;
+    const auto* min_ring_size =
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_minimum_ring_size(
+            resource);
+    if (min_ring_size != nullptr) {
+      json.emplace("minRingSize",
+                   google_protobuf_UInt64Value_value(min_ring_size));
+    }
+    const auto* max_ring_size =
+        envoy_extensions_load_balancing_policies_ring_hash_v3_RingHash_maximum_ring_size(
+            resource);
+    if (max_ring_size != nullptr) {
+      json.emplace("maxRingSize",
+                   google_protobuf_UInt64Value_value(max_ring_size));
+    }
+    return Json::Object{{"ring_hash_experimental", std::move(json)}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.ring_hash.v3.RingHash";
+  }
+};
+
+class RoundRobinLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+      const XdsEncodingContext& /* context */,
+      absl::string_view /* configuration */,
+      int /* recursion_depth */) override {
+    return Json::Object{{"round_robin", Json::Object()}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.round_robin.v3.RoundRobin";
+  }
+};
+
+class WrrLocalityLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+      const XdsEncodingContext& context, absl::string_view configuration,
+      int recursion_depth) override {
+    const auto* resource =
+        envoy_extensions_load_balancing_policies_wrr_locality_v3_WrrLocality_parse(
+            configuration.data(), configuration.size(), context.arena);
+    if (resource == nullptr) {
+      return absl::InvalidArgumentError(
+          "Can't decode WrrLocality loadbalancing policy");
+    }
+    const auto* endpoint_picking_policy =
+        envoy_extensions_load_balancing_policies_wrr_locality_v3_WrrLocality_endpoint_picking_policy(
+            resource);
+    if (endpoint_picking_policy == nullptr) {
+      return absl::InvalidArgumentError(
+          "WrrLocality: endpoint_picking_policy not found");
+    }
+    auto child_policy = XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
+        context, endpoint_picking_policy, recursion_depth + 1);
+    if (!child_policy.ok()) {
+      return absl::InvalidArgumentError(
+          absl::StrCat("Error parsing WrrLocality load balancing policy: ",
+                       child_policy.status().message()));
+    }
+    return Json::Object{
+        {"xds_wrr_locality_experimental",
+         Json::Object{{"child_policy", *std::move(child_policy)}}}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.wrr_locality.v3."
+           "WrrLocality";
+  }
+};
+
+absl::StatusOr<Json> ParseStructToJson(const XdsEncodingContext& context,
+                                       const google_protobuf_Struct* resource) {
+  upb::Status status;
+  const auto* msg_def = google_protobuf_Struct_getmsgdef(context.symtab);
+  size_t json_size = upb_JsonEncode(resource, msg_def, context.symtab, 0,
+                                    nullptr, 0, status.ptr());
+  if (json_size == static_cast<size_t>(-1)) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Error parsing google::Protobuf::Struct: ",
+                     upb_Status_ErrorMessage(status.ptr())));
+  }
+  void* buf = upb_Arena_Malloc(context.arena, json_size + 1);
+  upb_JsonEncode(resource, msg_def, context.symtab, 0,
+                 reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  auto json = Json::Parse(reinterpret_cast<char*>(buf), &error);
+  if (!GRPC_ERROR_IS_NONE(error)) {
+    // This should not happen
+    auto ret_status = absl::InternalError(
+        absl::StrCat("Error parsing JSON form of google::Protobuf::Struct "
+                     "produced by upb library: ",
+                     grpc_error_std_string(error)));
+    GRPC_ERROR_UNREF(error);
+    return ret_status;
+  }
+  return json;
+}
+
+}  // namespace
+
+//
+// XdsLbPolicyRegistry
+//
+
+absl::StatusOr<Json::Array> XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
+    const XdsEncodingContext& context,
+    const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
+    int recursion_depth) {
+  constexpr int kMaxRecursionDepth = 16;
+  if (recursion_depth >= kMaxRecursionDepth) {
+    return absl::InvalidArgumentError(
+        absl::StrFormat("LoadBalancingPolicy configuration has a recursion "
+                        "depth of more than %d.",
+                        kMaxRecursionDepth));
+  }
+  size_t size = 0;
+  const auto* policies =
+      envoy_config_cluster_v3_LoadBalancingPolicy_policies(lb_policy, &size);
+  for (size_t i = 0; i < size; ++i) {
+    absl::StatusOr<Json::Object> policy;
+    const auto* typed_extension_config =
+        envoy_config_cluster_v3_LoadBalancingPolicy_Policy_typed_extension_config(
+            policies[i]);
+    if (typed_extension_config == nullptr) {
+      return absl::InvalidArgumentError(
+          "Error parsing LoadBalancingPolicy::Policy - Missing "
+          "typed_extension_config field");
+    }
+    const auto* typed_config =
+        envoy_config_core_v3_TypedExtensionConfig_typed_config(
+            typed_extension_config);
+    if (typed_config == nullptr) {
+      return absl::InvalidArgumentError(
+          "Error parsing LoadBalancingPolicy::Policy - Missing "
+          "TypedExtensionConfig::typed_config field");
+    }
+    auto type = ExtractExtensionTypeName(context, typed_config);
+    if (!type.ok()) {
+      return absl::InvalidArgumentError(absl::StrCat(
+          "Error parsing "
+          "LoadBalancingPolicy::Policy::TypedExtensionConfig::typed_config: ",
+          type.status().message()));
+    }
+    absl::string_view value =
+        UpbStringToAbsl(google_protobuf_Any_value(typed_config));
+    auto config_factory_it = Get()->policy_config_factories_.find(type->type);
+    if (config_factory_it != Get()->policy_config_factories_.end()) {
+      policy = config_factory_it->second->ConvertXdsLbPolicyConfig(
+          context, value, recursion_depth);
+      if (!policy.ok()) {
+        return absl::InvalidArgumentError(
+            absl::StrCat("Error parsing "
+                         "LoadBalancingPolicy::Policy::TypedExtensionConfig::"
+                         "typed_config to JSON: ",
+                         policy.status().message()));
+      }
+    } else if (type->typed_struct != nullptr) {
+      // Custom lb policy config
+      std::string custom_type = std::string(type->type);
+      if (!LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
+              custom_type.c_str(), nullptr)) {
+        // Skip unsupported custom lb policy.
+        continue;
+      }
+      // Convert typed struct to json.
+      auto value = xds_type_v3_TypedStruct_value(type->typed_struct);
+      if (value == nullptr) {
+        policy = Json::Object{{std::move(custom_type), Json() /* null */}};
+      } else {
+        auto parsed_value = ParseStructToJson(context, value);
+        if (!parsed_value.ok()) {
+          return absl::InvalidArgumentError(absl::StrCat(
+              "Error parsing LoadBalancingPolicy: Custom Policy: ", custom_type,
+              ": ", parsed_value.status().message()));
+        }
+        policy =
+            Json::Object{{std::move(custom_type), *(std::move(parsed_value))}};
+      }
+    } else {
+      // Unsupported type. Skipping entry.
+      continue;
+    }
+    return Json::Array{std::move(policy.value())};
+  }
+  return absl::InvalidArgumentError(
+      "No supported load balancing policy config found.");
+}
+
+XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
+  policy_config_factories_.emplace(
+      RingHashLbPolicyConfigFactory::Type(),
+      absl::make_unique<RingHashLbPolicyConfigFactory>());
+  policy_config_factories_.emplace(
+      RoundRobinLbPolicyConfigFactory::Type(),
+      absl::make_unique<RoundRobinLbPolicyConfigFactory>());
+  policy_config_factories_.emplace(
+      WrrLocalityLbPolicyConfigFactory::Type(),
+      absl::make_unique<WrrLocalityLbPolicyConfigFactory>());
+}
+
+XdsLbPolicyRegistry* XdsLbPolicyRegistry::Get() {
+  // This is thread-safe since C++11
+  static XdsLbPolicyRegistry* instance = new XdsLbPolicyRegistry();
+  return instance;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,72 @@
+//
+// Copyright 2022 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_CORE_EXT_XDS_XDS_LB_POLICY_REGISTRY_H
+#define GRPC_CORE_EXT_XDS_XDS_LB_POLICY_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <map>
+#include <memory>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "envoy/config/cluster/v3/cluster.upb.h"
+
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+// A registry that maintans a set of converters that are able to map xDS
+// loadbalancing policy configurations to gRPC's JSON format.
+class XdsLbPolicyRegistry {
+ public:
+  class ConfigFactory {
+   public:
+    virtual ~ConfigFactory() {}
+    virtual absl::StatusOr<Json::Object> ConvertXdsLbPolicyConfig(
+        const XdsEncodingContext& context, absl::string_view configuration,
+        int recursion_depth) = 0;
+
+    virtual absl::string_view type() = 0;
+  };
+
+  // Converts an xDS cluster load balancing policy message to gRPC's JSON
+  // format. An error is returned if none of the lb policies in the list are
+  // supported, or if a supported lb policy configuration conversion fails. \a
+  // recursion_depth indicates the current depth of the tree if lb_policy
+  // configuration recursively holds other lb policies.
+  static absl::StatusOr<Json::Array> ConvertXdsLbPolicyConfig(
+      const XdsEncodingContext& context,
+      const envoy_config_cluster_v3_LoadBalancingPolicy* lb_policy,
+      int recursion_depth = 0);
+
+ private:
+  XdsLbPolicyRegistry();
+
+  static XdsLbPolicyRegistry* Get();
+
+  // A map of config factories that goes from the type of the lb policy config
+  // to the config factory.
+  std::map<absl::string_view /* Owned by ConfigFactory */,
+           std::unique_ptr<ConfigFactory>>
+      policy_config_factories_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_LB_POLICY_REGISTRY_H

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

@@ -18,10 +18,17 @@
 
 #include "src/core/ext/xds/xds_listener.h"
 
+#include <stdint.h>
+
+#include <set>
+#include <type_traits>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "absl/strings/str_split.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"
@@ -30,18 +37,29 @@
 #include "envoy/config/listener/v3/listener.upb.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/config/listener/v3/listener_components.upb.h"
+#include "envoy/config/route/v3/route.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
+#include "envoy/extensions/transport_sockets/tls/v3/tls.upb.h"
+#include "google/protobuf/any.upb.h"
+#include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 #include "upb/text_encode.h"
 #include "upb/upb.h"
-#include "upb/upb.hpp"
+
+#include <grpc/support/log.h>
 
 #include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
 
@@ -64,7 +82,7 @@ bool XdsListenerResource::DownstreamTlsContext::Empty() const {
 //
 
 std::string XdsListenerResource::HttpConnectionManager::ToString() const {
-  absl::InlinedVector<std::string, 4> contents;
+  std::vector<std::string> contents;
   contents.push_back(absl::StrFormat(
       "route_config_name=%s",
       !route_config_name.empty() ? route_config_name.c_str() : "<inlined>"));
@@ -140,7 +158,7 @@ struct FilterChain {
 };
 
 std::string FilterChain::FilterChainMatch::ToString() const {
-  absl::InlinedVector<std::string, 8> contents;
+  std::vector<std::string> contents;
   if (destination_port != 0) {
     contents.push_back(absl::StrCat("destination_port=", destination_port));
   }
@@ -229,7 +247,7 @@ std::string XdsListenerResource::FilterChainMap::ToString() const {
 //
 
 std::string XdsListenerResource::ToString() const {
-  absl::InlinedVector<std::string, 4> contents;
+  std::vector<std::string> contents;
   if (type == ListenerType::kTcpListener) {
     contents.push_back(absl::StrCat("address=", address));
     contents.push_back(
@@ -332,30 +350,30 @@ grpc_error_handle HttpConnectionManagerParse(
         return GRPC_ERROR_CREATE_FROM_CPP_STRING(
             absl::StrCat("no filter config specified for filter name ", name));
       }
-      absl::string_view filter_type;
-      grpc_error_handle error =
-          ExtractExtensionTypeName(context, any, &filter_type);
-      if (error != GRPC_ERROR_NONE) return error;
+      auto filter_type = ExtractExtensionTypeName(context, any);
+      if (!filter_type.ok()) {
+        return absl_status_to_grpc_error(filter_type.status());
+      }
       const XdsHttpFilterImpl* filter_impl =
-          XdsHttpFilterRegistry::GetFilterForType(filter_type);
+          XdsHttpFilterRegistry::GetFilterForType(filter_type->type);
       if (filter_impl == nullptr) {
         if (is_optional) continue;
-        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
-            absl::StrCat("no filter registered for config type ", filter_type));
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+            "no filter registered for config type ", filter_type->type));
       }
       if ((is_client && !filter_impl->IsSupportedOnClients()) ||
           (!is_client && !filter_impl->IsSupportedOnServers())) {
         if (is_optional) continue;
-        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
-            absl::StrFormat("Filter %s is not supported on %s", filter_type,
-                            is_client ? "clients" : "servers"));
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+            "Filter %s is not supported on %s", filter_type->type,
+            is_client ? "clients" : "servers"));
       }
       absl::StatusOr<XdsHttpFilterImpl::FilterConfig> filter_config =
           filter_impl->GenerateFilterConfig(google_protobuf_Any_value(any),
                                             context.arena);
       if (!filter_config.ok()) {
         return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-            "filter config for type ", filter_type,
+            "filter config for type ", filter_type->type,
             " failed to parse: ", StatusToString(filter_config.status())));
       }
       http_connection_manager->http_filters.emplace_back(
@@ -414,7 +432,7 @@ grpc_error_handle HttpConnectionManagerParse(
       XdsRouteConfigResource rds_update;
       grpc_error_handle error =
           XdsRouteConfigResource::Parse(context, route_config, &rds_update);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
       http_connection_manager->rds_update = std::move(rds_update);
       return GRPC_ERROR_NONE;
     }
@@ -498,7 +516,7 @@ grpc_error_handle DownstreamTlsContextParse(
       grpc_error_handle error =
           CommonTlsContext::Parse(context, common_tls_context,
                                   &downstream_tls_context->common_tls_context);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     }
     auto* require_client_certificate =
         envoy_extensions_transport_sockets_tls_v3_DownstreamTlsContext_require_client_certificate(
@@ -551,7 +569,7 @@ grpc_error_handle CidrRangeParse(
       envoy_config_core_v3_CidrRange_address_prefix(cidr_range_proto));
   grpc_error_handle error =
       grpc_string_to_sockaddr(&cidr_range->address, address_prefix.c_str(), 0);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   cidr_range->prefix_len = 0;
   auto* prefix_len_proto =
       envoy_config_core_v3_CidrRange_prefix_len(cidr_range_proto);
@@ -585,7 +603,7 @@ grpc_error_handle FilterChainMatchParse(
   for (size_t i = 0; i < size; i++) {
     XdsListenerResource::FilterChainMap::CidrRange cidr_range;
     grpc_error_handle error = CidrRangeParse(prefix_ranges[i], &cidr_range);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     filter_chain_match->prefix_ranges.push_back(cidr_range);
   }
   filter_chain_match->source_type =
@@ -600,7 +618,7 @@ grpc_error_handle FilterChainMatchParse(
     XdsListenerResource::FilterChainMap::CidrRange cidr_range;
     grpc_error_handle error =
         CidrRangeParse(source_prefix_ranges[i], &cidr_range);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     filter_chain_match->source_prefix_ranges.push_back(cidr_range);
   }
   auto* source_ports = envoy_config_listener_v3_FilterChainMatch_source_ports(
@@ -639,7 +657,7 @@ grpc_error_handle FilterChainParse(
   if (filter_chain_match != nullptr) {
     grpc_error_handle error = FilterChainMatchParse(
         filter_chain_match, &filter_chain->filter_chain_match);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   }
   filter_chain->filter_chain_data =
       std::make_shared<XdsListenerResource::FilterChainData>();
@@ -681,7 +699,7 @@ grpc_error_handle FilterChainParse(
           grpc_error_handle error = HttpConnectionManagerParse(
               false /* is_client */, context, http_connection_manager, is_v2,
               &filter_chain->filter_chain_data->http_connection_manager);
-          if (error != GRPC_ERROR_NONE) errors.push_back(error);
+          if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
         }
       }
     }
@@ -692,7 +710,7 @@ grpc_error_handle FilterChainParse(
     grpc_error_handle error = DownstreamTlsContextParse(
         context, transport_socket,
         &filter_chain->filter_chain_data->downstream_tls_context);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("Error parsing FilterChain", &errors);
 }
@@ -761,7 +779,7 @@ grpc_error_handle AddFilterChainDataForSourcePorts(
     for (uint32_t port : filter_chain.filter_chain_match.source_ports) {
       grpc_error_handle error =
           AddFilterChainDataForSourcePort(filter_chain, ports_map, port);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
   }
   return GRPC_ERROR_NONE;
@@ -790,7 +808,7 @@ grpc_error_handle AddFilterChainDataForSourceIpRange(
       }
       grpc_error_handle error = AddFilterChainDataForSourcePorts(
           filter_chain, &insert_result.first->second.ports_map);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
   }
   return GRPC_ERROR_NONE;
@@ -877,7 +895,7 @@ grpc_error_handle AddFilterChainDataForDestinationIpRange(
       }
       grpc_error_handle error = AddFilterChainDataForServerNames(
           filter_chain, &insert_result.first->second);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
   }
   return GRPC_ERROR_NONE;
@@ -911,7 +929,7 @@ grpc_error_handle BuildFilterChainMap(
     if (filter_chain.filter_chain_match.destination_port != 0) continue;
     grpc_error_handle error = AddFilterChainDataForDestinationIpRange(
         filter_chain, &internal_filter_chain_map.destination_ip_map);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
   }
   *filter_chain_map =
       BuildFromInternalFilterChainMap(&internal_filter_chain_map);
@@ -926,7 +944,7 @@ grpc_error_handle LdsResourceParseServer(
   grpc_error_handle error =
       AddressParse(envoy_config_listener_v3_Listener_address(listener),
                    &lds_update->address);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   const auto* use_original_dst =
       envoy_config_listener_v3_Listener_use_original_dst(listener);
   if (use_original_dst != nullptr) {
@@ -943,19 +961,19 @@ grpc_error_handle LdsResourceParseServer(
   for (size_t i = 0; i < size; i++) {
     FilterChain filter_chain;
     error = FilterChainParse(context, filter_chains[i], is_v2, &filter_chain);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     parsed_filter_chains.push_back(std::move(filter_chain));
   }
   error =
       BuildFilterChainMap(parsed_filter_chains, &lds_update->filter_chain_map);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   auto* default_filter_chain =
       envoy_config_listener_v3_Listener_default_filter_chain(listener);
   if (default_filter_chain != nullptr) {
     FilterChain filter_chain;
     error =
         FilterChainParse(context, default_filter_chain, is_v2, &filter_chain);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     if (filter_chain.filter_chain_data != nullptr) {
       lds_update->default_filter_chain =
           std::move(*filter_chain.filter_chain_data);
@@ -1027,7 +1045,7 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsListenerResourceType::Decode(
   auto listener_data = absl::make_unique<ResourceDataSubclass>();
   grpc_error_handle error =
       LdsResourceParse(context, resource, is_v2, &listener_data->resource);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string error_str = grpc_error_std_string(error);
     GRPC_ERROR_UNREF(error);
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {

data/src/core/ext/xds/xds_listener.h

@@ -19,8 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+#include <string.h>
+
+#include <algorithm>
 #include <array>
+#include <cstdint>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -29,12 +35,15 @@
 #include "absl/types/optional.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
+#include "upb/def.h"
 
-#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/ext/xds/xds_route_config.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 

data/src/core/ext/xds/xds_resource_type.h

@@ -14,6 +14,8 @@
 // limitations under the License.
 //
 
+#ifndef GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
+#define GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
 #include <grpc/support/port_platform.h>
 
 #include <memory>
@@ -21,12 +23,10 @@
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "upb/def.h"
 
 #include "src/core/ext/xds/upb_utils.h"
 
-#ifndef GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
-#define GRPC_CORE_EXT_XDS_XDS_RESOURCE_TYPE_H
-
 namespace grpc_core {
 
 // Interface for an xDS resource type.