grpc 1.42.0 → 1.45.0

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

@@ -0,0 +1,364 @@
+//
+// Copyright 2018 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_endpoint.h"
+
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.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/health_check.upb.h"
+#include "envoy/config/endpoint/v3/endpoint.upb.h"
+#include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
+#include "envoy/config/endpoint/v3/endpoint_components.upb.h"
+#include "envoy/type/v3/percent.upb.h"
+#include "google/protobuf/wrappers.upb.h"
+#include "upb/text_encode.h"
+#include "upb/upb.h"
+#include "upb/upb.hpp"
+
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+
+namespace grpc_core {
+
+//
+// XdsEndpointResource
+//
+
+std::string XdsEndpointResource::Priority::Locality::ToString() const {
+  std::vector<std::string> endpoint_strings;
+  for (const ServerAddress& endpoint : endpoints) {
+    endpoint_strings.emplace_back(endpoint.ToString());
+  }
+  return absl::StrCat("{name=", name->AsHumanReadableString(),
+                      ", lb_weight=", lb_weight, ", endpoints=[",
+                      absl::StrJoin(endpoint_strings, ", "), "]}");
+}
+
+bool XdsEndpointResource::Priority::operator==(const Priority& other) const {
+  if (localities.size() != other.localities.size()) return false;
+  auto it1 = localities.begin();
+  auto it2 = other.localities.begin();
+  while (it1 != localities.end()) {
+    if (*it1->first != *it2->first) return false;
+    if (it1->second != it2->second) return false;
+    ++it1;
+    ++it2;
+  }
+  return true;
+}
+
+std::string XdsEndpointResource::Priority::ToString() const {
+  std::vector<std::string> locality_strings;
+  for (const auto& p : localities) {
+    locality_strings.emplace_back(p.second.ToString());
+  }
+  return absl::StrCat("[", absl::StrJoin(locality_strings, ", "), "]");
+}
+
+bool XdsEndpointResource::DropConfig::ShouldDrop(
+    const std::string** category_name) const {
+  for (size_t i = 0; i < drop_category_list_.size(); ++i) {
+    const auto& drop_category = drop_category_list_[i];
+    // Generate a random number in [0, 1000000).
+    const uint32_t random = static_cast<uint32_t>(rand()) % 1000000;
+    if (random < drop_category.parts_per_million) {
+      *category_name = &drop_category.name;
+      return true;
+    }
+  }
+  return false;
+}
+
+std::string XdsEndpointResource::DropConfig::ToString() const {
+  std::vector<std::string> category_strings;
+  for (const DropCategory& category : drop_category_list_) {
+    category_strings.emplace_back(
+        absl::StrCat(category.name, "=", category.parts_per_million));
+  }
+  return absl::StrCat("{[", absl::StrJoin(category_strings, ", "),
+                      "], drop_all=", drop_all_, "}");
+}
+
+std::string XdsEndpointResource::ToString() const {
+  std::vector<std::string> priority_strings;
+  for (size_t i = 0; i < priorities.size(); ++i) {
+    const Priority& priority = priorities[i];
+    priority_strings.emplace_back(
+        absl::StrCat("priority ", i, ": ", priority.ToString()));
+  }
+  return absl::StrCat("priorities=[", absl::StrJoin(priority_strings, ", "),
+                      "], drop_config=", drop_config->ToString());
+}
+
+//
+// XdsEndpointResourceType
+//
+
+namespace {
+
+void MaybeLogClusterLoadAssignment(
+    const XdsEncodingContext& context,
+    const envoy_config_endpoint_v3_ClusterLoadAssignment* cla) {
+  if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    const upb_MessageDef* msg_type =
+        envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(
+            context.symtab);
+    char buf[10240];
+    upb_TextEncode(cla, msg_type, nullptr, 0, buf, sizeof(buf));
+    gpr_log(GPR_DEBUG, "[xds_client %p] ClusterLoadAssignment: %s",
+            context.client, buf);
+  }
+}
+
+grpc_error_handle ServerAddressParseAndAppend(
+    const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint,
+    ServerAddressList* list) {
+  // If health_status is not HEALTHY or UNKNOWN, skip this endpoint.
+  const int32_t health_status =
+      envoy_config_endpoint_v3_LbEndpoint_health_status(lb_endpoint);
+  if (health_status != envoy_config_core_v3_UNKNOWN &&
+      health_status != envoy_config_core_v3_HEALTHY) {
+    return GRPC_ERROR_NONE;
+  }
+  // Find the ip:port.
+  const envoy_config_endpoint_v3_Endpoint* endpoint =
+      envoy_config_endpoint_v3_LbEndpoint_endpoint(lb_endpoint);
+  const envoy_config_core_v3_Address* address =
+      envoy_config_endpoint_v3_Endpoint_address(endpoint);
+  const envoy_config_core_v3_SocketAddress* socket_address =
+      envoy_config_core_v3_Address_socket_address(address);
+  std::string address_str = UpbStringToStdString(
+      envoy_config_core_v3_SocketAddress_address(socket_address));
+  uint32_t port = envoy_config_core_v3_SocketAddress_port_value(socket_address);
+  if (GPR_UNLIKELY(port >> 16) != 0) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Invalid port.");
+  }
+  // Find load_balancing_weight for the endpoint.
+  const google_protobuf_UInt32Value* load_balancing_weight =
+      envoy_config_endpoint_v3_LbEndpoint_load_balancing_weight(lb_endpoint);
+  const int32_t weight =
+      load_balancing_weight != nullptr
+          ? google_protobuf_UInt32Value_value(load_balancing_weight)
+          : 500;
+  if (weight == 0) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Invalid endpoint weight of 0.");
+  }
+  // Populate grpc_resolved_address.
+  grpc_resolved_address addr;
+  grpc_error_handle error =
+      grpc_string_to_sockaddr(&addr, address_str.c_str(), port);
+  if (error != GRPC_ERROR_NONE) return error;
+  // Append the address to the list.
+  std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
+      attributes;
+  attributes[ServerAddressWeightAttribute::kServerAddressWeightAttributeKey] =
+      absl::make_unique<ServerAddressWeightAttribute>(weight);
+  list->emplace_back(addr, nullptr, std::move(attributes));
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error_handle LocalityParse(
+    const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints,
+    XdsEndpointResource::Priority::Locality* output_locality,
+    size_t* priority) {
+  // Parse LB weight.
+  const google_protobuf_UInt32Value* lb_weight =
+      envoy_config_endpoint_v3_LocalityLbEndpoints_load_balancing_weight(
+          locality_lb_endpoints);
+  // If LB weight is not specified, it means this locality is assigned no load.
+  // TODO(juanlishen): When we support CDS to configure the inter-locality
+  // policy, we should change the LB weight handling.
+  output_locality->lb_weight =
+      lb_weight != nullptr ? google_protobuf_UInt32Value_value(lb_weight) : 0;
+  if (output_locality->lb_weight == 0) return GRPC_ERROR_NONE;
+  // Parse locality name.
+  const envoy_config_core_v3_Locality* locality =
+      envoy_config_endpoint_v3_LocalityLbEndpoints_locality(
+          locality_lb_endpoints);
+  if (locality == nullptr) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty locality.");
+  }
+  std::string region =
+      UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
+  std::string zone =
+      UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
+  std::string sub_zone =
+      UpbStringToStdString(envoy_config_core_v3_Locality_sub_zone(locality));
+  output_locality->name = MakeRefCounted<XdsLocalityName>(
+      std::move(region), std::move(zone), std::move(sub_zone));
+  // Parse the addresses.
+  size_t size;
+  const envoy_config_endpoint_v3_LbEndpoint* const* lb_endpoints =
+      envoy_config_endpoint_v3_LocalityLbEndpoints_lb_endpoints(
+          locality_lb_endpoints, &size);
+  for (size_t i = 0; i < size; ++i) {
+    grpc_error_handle error = ServerAddressParseAndAppend(
+        lb_endpoints[i], &output_locality->endpoints);
+    if (error != GRPC_ERROR_NONE) return error;
+  }
+  // Parse the priority.
+  *priority = envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
+      locality_lb_endpoints);
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error_handle DropParseAndAppend(
+    const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload*
+        drop_overload,
+    XdsEndpointResource::DropConfig* drop_config) {
+  // Get the category.
+  std::string category = UpbStringToStdString(
+      envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload_category(
+          drop_overload));
+  if (category.empty()) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty drop category name");
+  }
+  // Get the drop rate (per million).
+  const envoy_type_v3_FractionalPercent* drop_percentage =
+      envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload_drop_percentage(
+          drop_overload);
+  uint32_t numerator =
+      envoy_type_v3_FractionalPercent_numerator(drop_percentage);
+  const auto denominator =
+      static_cast<envoy_type_v3_FractionalPercent_DenominatorType>(
+          envoy_type_v3_FractionalPercent_denominator(drop_percentage));
+  // Normalize to million.
+  switch (denominator) {
+    case envoy_type_v3_FractionalPercent_HUNDRED:
+      numerator *= 10000;
+      break;
+    case envoy_type_v3_FractionalPercent_TEN_THOUSAND:
+      numerator *= 100;
+      break;
+    case envoy_type_v3_FractionalPercent_MILLION:
+      break;
+    default:
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unknown denominator type");
+  }
+  // Cap numerator to 1000000.
+  numerator = std::min(numerator, 1000000u);
+  drop_config->AddCategory(std::move(category), numerator);
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error_handle EdsResourceParse(
+    const XdsEncodingContext& /*context*/,
+    const envoy_config_endpoint_v3_ClusterLoadAssignment*
+        cluster_load_assignment,
+    bool /*is_v2*/, XdsEndpointResource* eds_update) {
+  std::vector<grpc_error_handle> errors;
+  // Get the endpoints.
+  size_t locality_size;
+  const envoy_config_endpoint_v3_LocalityLbEndpoints* const* endpoints =
+      envoy_config_endpoint_v3_ClusterLoadAssignment_endpoints(
+          cluster_load_assignment, &locality_size);
+  for (size_t j = 0; j < locality_size; ++j) {
+    size_t priority;
+    XdsEndpointResource::Priority::Locality locality;
+    grpc_error_handle error = LocalityParse(endpoints[j], &locality, &priority);
+    if (error != GRPC_ERROR_NONE) {
+      errors.push_back(error);
+      continue;
+    }
+    // Filter out locality with weight 0.
+    if (locality.lb_weight == 0) continue;
+    // Make sure prorities is big enough. Note that they might not
+    // arrive in priority order.
+    while (eds_update->priorities.size() < priority + 1) {
+      eds_update->priorities.emplace_back();
+    }
+    eds_update->priorities[priority].localities.emplace(locality.name.get(),
+                                                        std::move(locality));
+  }
+  for (const auto& priority : eds_update->priorities) {
+    if (priority.localities.empty()) {
+      errors.push_back(
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("sparse priority list"));
+    }
+  }
+  // Get the drop config.
+  eds_update->drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
+  const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy* policy =
+      envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
+          cluster_load_assignment);
+  if (policy != nullptr) {
+    size_t drop_size;
+    const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload* const*
+        drop_overload =
+            envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_drop_overloads(
+                policy, &drop_size);
+    for (size_t j = 0; j < drop_size; ++j) {
+      grpc_error_handle error =
+          DropParseAndAppend(drop_overload[j], eds_update->drop_config.get());
+      if (error != GRPC_ERROR_NONE) {
+        errors.push_back(
+            grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                                     "drop config validation error"),
+                                 error));
+      }
+    }
+  }
+  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing EDS resource", &errors);
+}
+
+}  // namespace
+
+absl::StatusOr<XdsResourceType::DecodeResult> XdsEndpointResourceType::Decode(
+    const XdsEncodingContext& context, absl::string_view serialized_resource,
+    bool is_v2) const {
+  // Parse serialized proto.
+  auto* resource = envoy_config_endpoint_v3_ClusterLoadAssignment_parse(
+      serialized_resource.data(), serialized_resource.size(), context.arena);
+  if (resource == nullptr) {
+    return absl::InvalidArgumentError(
+        "Can't parse ClusterLoadAssignment resource.");
+  }
+  MaybeLogClusterLoadAssignment(context, resource);
+  // Validate resource.
+  DecodeResult result;
+  result.name = UpbStringToStdString(
+      envoy_config_endpoint_v3_ClusterLoadAssignment_cluster_name(resource));
+  auto endpoint_data = absl::make_unique<ResourceDataSubclass>();
+  grpc_error_handle error =
+      EdsResourceParse(context, resource, is_v2, &endpoint_data->resource);
+  if (error != GRPC_ERROR_NONE) {
+    std::string error_str = grpc_error_std_string(error);
+    GRPC_ERROR_UNREF(error);
+    if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
+      gpr_log(GPR_ERROR, "[xds_client %p] invalid ClusterLoadAssignment %s: %s",
+              context.client, result.name.c_str(), error_str.c_str());
+    }
+    result.resource = absl::InvalidArgumentError(error_str);
+  } else {
+    if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
+      gpr_log(GPR_INFO, "[xds_client %p] parsed ClusterLoadAssignment %s: %s",
+              context.client, result.name.c_str(),
+              endpoint_data->resource.ToString().c_str());
+    }
+    result.resource = std::move(endpoint_data);
+  }
+  return std::move(result);
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,135 @@
+//
+// Copyright 2018 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_ENDPOINT_H
+#define GRPC_CORE_EXT_XDS_XDS_ENDPOINT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "absl/container/inlined_vector.h"
+#include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
+
+#include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_resource_type_impl.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/resolver/server_address.h"
+
+namespace grpc_core {
+
+struct XdsEndpointResource {
+  struct Priority {
+    struct Locality {
+      RefCountedPtr<XdsLocalityName> name;
+      uint32_t lb_weight;
+      ServerAddressList endpoints;
+
+      bool operator==(const Locality& other) const {
+        return *name == *other.name && lb_weight == other.lb_weight &&
+               endpoints == other.endpoints;
+      }
+      bool operator!=(const Locality& other) const { return !(*this == other); }
+      std::string ToString() const;
+    };
+
+    std::map<XdsLocalityName*, Locality, XdsLocalityName::Less> localities;
+
+    bool operator==(const Priority& other) const;
+    std::string ToString() const;
+  };
+  using PriorityList = absl::InlinedVector<Priority, 2>;
+
+  // There are two phases of accessing this class's content:
+  // 1. to initialize in the control plane combiner;
+  // 2. to use in the data plane combiner.
+  // So no additional synchronization is needed.
+  class DropConfig : public RefCounted<DropConfig> {
+   public:
+    struct DropCategory {
+      bool operator==(const DropCategory& other) const {
+        return name == other.name &&
+               parts_per_million == other.parts_per_million;
+      }
+
+      std::string name;
+      const uint32_t parts_per_million;
+    };
+
+    using DropCategoryList = absl::InlinedVector<DropCategory, 2>;
+
+    void AddCategory(std::string name, uint32_t parts_per_million) {
+      drop_category_list_.emplace_back(
+          DropCategory{std::move(name), parts_per_million});
+      if (parts_per_million == 1000000) drop_all_ = true;
+    }
+
+    // The only method invoked from outside the WorkSerializer (used in
+    // the data plane).
+    bool ShouldDrop(const std::string** category_name) const;
+
+    const DropCategoryList& drop_category_list() const {
+      return drop_category_list_;
+    }
+
+    bool drop_all() const { return drop_all_; }
+
+    bool operator==(const DropConfig& other) const {
+      return drop_category_list_ == other.drop_category_list_;
+    }
+    bool operator!=(const DropConfig& other) const { return !(*this == other); }
+
+    std::string ToString() const;
+
+   private:
+    DropCategoryList drop_category_list_;
+    bool drop_all_ = false;
+  };
+
+  PriorityList priorities;
+  RefCountedPtr<DropConfig> drop_config;
+
+  bool operator==(const XdsEndpointResource& other) const {
+    return priorities == other.priorities && *drop_config == *other.drop_config;
+  }
+  std::string ToString() const;
+};
+
+class XdsEndpointResourceType
+    : public XdsResourceTypeImpl<XdsEndpointResourceType, XdsEndpointResource> {
+ public:
+  absl::string_view type_url() const override {
+    return "envoy.config.endpoint.v3.ClusterLoadAssignment";
+  }
+  absl::string_view v2_type_url() const override {
+    return "envoy.api.v2.ClusterLoadAssignment";
+  }
+
+  absl::StatusOr<DecodeResult> Decode(const XdsEncodingContext& context,
+                                      absl::string_view serialized_resource,
+                                      bool is_v2) const override;
+
+  void InitUpbSymtab(upb_DefPool* symtab) const override {
+    envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(symtab);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_ENDPOINT_H

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

@@ -69,8 +69,8 @@ uint32_t GetDenominator(const envoy_type_v3_FractionalPercent* fraction) {
   return 100;
 }
 
-absl::StatusOr<Json> ParseHttpFaultIntoJson(upb_strview serialized_http_fault,
-                                            upb_arena* arena) {
+absl::StatusOr<Json> ParseHttpFaultIntoJson(
+    upb_StringView serialized_http_fault, upb_Arena* arena) {
   auto* http_fault = envoy_extensions_filters_http_fault_v3_HTTPFault_parse(
       serialized_http_fault.data, serialized_http_fault.size, arena);
   if (http_fault == nullptr) {
@@ -174,13 +174,13 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(upb_strview serialized_http_fault,
 
 }  // namespace
 
-void XdsHttpFaultFilter::PopulateSymtab(upb_symtab* symtab) const {
+void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_fault_v3_HTTPFault_getmsgdef(symtab);
 }
 
 absl::StatusOr<XdsHttpFilterImpl::FilterConfig>
-XdsHttpFaultFilter::GenerateFilterConfig(upb_strview serialized_filter_config,
-                                         upb_arena* arena) const {
+XdsHttpFaultFilter::GenerateFilterConfig(
+    upb_StringView serialized_filter_config, upb_Arena* arena) const {
   absl::StatusOr<Json> parse_result =
       ParseHttpFaultIntoJson(serialized_filter_config, arena);
   if (!parse_result.ok()) {
@@ -191,7 +191,7 @@ XdsHttpFaultFilter::GenerateFilterConfig(upb_strview serialized_filter_config,
 
 absl::StatusOr<XdsHttpFilterImpl::FilterConfig>
 XdsHttpFaultFilter::GenerateFilterConfigOverride(
-    upb_strview serialized_filter_config, upb_arena* arena) const {
+    upb_StringView serialized_filter_config, upb_Arena* arena) const {
   // HTTPFault filter has the same message type in HTTP connection manager's
   // filter config and in overriding filter config field.
   return GenerateFilterConfig(serialized_filter_config, arena);

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

@@ -33,15 +33,15 @@ extern const char* kXdsHttpFaultFilterConfigName;
 class XdsHttpFaultFilter : public XdsHttpFilterImpl {
  public:
   // Overrides the PopulateSymtab method
-  void PopulateSymtab(upb_symtab* symtab) const override;
+  void PopulateSymtab(upb_DefPool* symtab) const override;
 
   // Overrides the GenerateFilterConfig method
   absl::StatusOr<FilterConfig> GenerateFilterConfig(
-      upb_strview serialized_filter_config, upb_arena* arena) const override;
+      upb_StringView serialized_filter_config, upb_Arena* arena) const override;
 
   // Overrides the GenerateFilterConfigOverride method
   absl::StatusOr<FilterConfig> GenerateFilterConfigOverride(
-      upb_strview serialized_filter_config, upb_arena* arena) const override;
+      upb_StringView serialized_filter_config, upb_Arena* arena) const override;
 
   // Overrides the channel_filter method
   const grpc_channel_filter* channel_filter() const override;

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

@@ -22,6 +22,7 @@
 #include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
 
 #include "src/core/ext/xds/xds_http_fault_filter.h"
+#include "src/core/ext/xds/xds_http_rbac_filter.h"
 
 namespace grpc_core {
 
@@ -32,12 +33,13 @@ namespace {
 
 class XdsHttpRouterFilter : public XdsHttpFilterImpl {
  public:
-  void PopulateSymtab(upb_symtab* symtab) const override {
+  void PopulateSymtab(upb_DefPool* symtab) const override {
     envoy_extensions_filters_http_router_v3_Router_getmsgdef(symtab);
   }
 
   absl::StatusOr<FilterConfig> GenerateFilterConfig(
-      upb_strview serialized_filter_config, upb_arena* arena) const override {
+      upb_StringView serialized_filter_config,
+      upb_Arena* arena) const override {
     if (envoy_extensions_filters_http_router_v3_Router_parse(
             serialized_filter_config.data, serialized_filter_config.size,
             arena) == nullptr) {
@@ -47,8 +49,8 @@ class XdsHttpRouterFilter : public XdsHttpFilterImpl {
   }
 
   absl::StatusOr<FilterConfig> GenerateFilterConfigOverride(
-      upb_strview /*serialized_filter_config*/,
-      upb_arena* /*arena*/) const override {
+      upb_StringView /*serialized_filter_config*/,
+      upb_Arena* /*arena*/) const override {
     return absl::InvalidArgumentError(
         "router filter does not support config override");
   }
@@ -93,7 +95,7 @@ const XdsHttpFilterImpl* XdsHttpFilterRegistry::GetFilterForType(
   return it->second;
 }
 
-void XdsHttpFilterRegistry::PopulateSymtab(upb_symtab* symtab) {
+void XdsHttpFilterRegistry::PopulateSymtab(upb_DefPool* symtab) {
   for (const auto& filter : *g_filters) {
     filter->PopulateSymtab(symtab);
   }
@@ -106,6 +108,10 @@ void XdsHttpFilterRegistry::Init() {
                  {kXdsHttpRouterFilterConfigName});
   RegisterFilter(absl::make_unique<XdsHttpFaultFilter>(),
                  {kXdsHttpFaultFilterConfigName});
+  RegisterFilter(absl::make_unique<XdsHttpRbacFilter>(),
+                 {kXdsHttpRbacFilterConfigName});
+  RegisterFilter(absl::make_unique<XdsHttpRbacFilter>(),
+                 {kXdsHttpRbacFilterConfigOverrideName});
 }
 
 void XdsHttpFilterRegistry::Shutdown() {

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

@@ -70,17 +70,17 @@ class XdsHttpFilterImpl {
   virtual ~XdsHttpFilterImpl() = default;
 
   // Loads the proto message into the upb symtab.
-  virtual void PopulateSymtab(upb_symtab* symtab) const = 0;
+  virtual void PopulateSymtab(upb_DefPool* symtab) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the top-level config in the HCM HTTP filter list.
   virtual absl::StatusOr<FilterConfig> GenerateFilterConfig(
-      upb_strview serialized_filter_config, upb_arena* arena) const = 0;
+      upb_StringView serialized_filter_config, upb_Arena* arena) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the typed_per_filter_config override in VirtualHost and Route.
   virtual absl::StatusOr<FilterConfig> GenerateFilterConfigOverride(
-      upb_strview serialized_filter_config, upb_arena* arena) const = 0;
+      upb_StringView serialized_filter_config, upb_Arena* arena) const = 0;
 
   // C-core channel filter implementation.
   virtual const grpc_channel_filter* channel_filter() const = 0;
@@ -121,7 +121,7 @@ class XdsHttpFilterRegistry {
   static const XdsHttpFilterImpl* GetFilterForType(
       absl::string_view proto_type_name);
 
-  static void PopulateSymtab(upb_symtab* symtab);
+  static void PopulateSymtab(upb_DefPool* symtab);
 
   // Global init and shutdown.
   static void Init();