grpc 1.45.0 → 1.47.0

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

@@ -27,6 +27,7 @@
 #include "envoy/extensions/clusters/aggregate/v3/cluster.upbdefs.h"
 #include "envoy/extensions/transport_sockets/tls/v3/tls.upbdefs.h"
 
+#include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
@@ -63,6 +64,8 @@ struct XdsClusterResource {
   // cluster.
   uint32_t max_concurrent_requests = 1024;
 
+  absl::optional<OutlierDetectionConfig> outlier_detection;
+
   bool operator==(const XdsClusterResource& other) const {
     return cluster_type == other.cluster_type &&
            eds_service_name == other.eds_service_name &&

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

@@ -0,0 +1,142 @@
+//
+// 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_cluster_specifier_plugin.h"
+
+#include "absl/strings/str_format.h"
+#include "envoy/extensions/filters/http/router/v3/router.upb.h"
+#include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
+#include "google/protobuf/duration.upb.h"
+#include "upb/json_encode.h"
+
+#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/ext/xds/upb_utils.h"
+#include "src/proto/grpc/lookup/v1/rls_config.upb.h"
+#include "src/proto/grpc/lookup/v1/rls_config.upbdefs.h"
+
+namespace grpc_core {
+
+const char* kXdsRouteLookupClusterSpecifierPluginConfigName =
+    "grpc.lookup.v1.RouteLookupClusterSpecifier";
+
+void XdsRouteLookupClusterSpecifierPlugin::PopulateSymtab(
+    upb_DefPool* symtab) const {
+  grpc_lookup_v1_RouteLookupConfig_getmsgdef(symtab);
+}
+
+absl::StatusOr<std::string>
+XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
+    upb_StringView serialized_plugin_config, upb_Arena* arena,
+    upb_DefPool* symtab) const {
+  const auto* specifier = grpc_lookup_v1_RouteLookupClusterSpecifier_parse(
+      serialized_plugin_config.data, serialized_plugin_config.size, arena);
+  if (specifier == nullptr) {
+    return absl::InvalidArgumentError("Could not parse plugin config");
+  }
+  const auto* plugin_config =
+      grpc_lookup_v1_RouteLookupClusterSpecifier_route_lookup_config(specifier);
+  if (plugin_config == nullptr) {
+    return absl::InvalidArgumentError(
+        "Could not get route lookup config from route lookup cluster "
+        "specifier");
+  }
+  upb::Status status;
+  const upb_MessageDef* msg_type =
+      grpc_lookup_v1_RouteLookupConfig_getmsgdef(symtab);
+  size_t json_size = upb_JsonEncode(plugin_config, msg_type, symtab, 0, nullptr,
+                                    0, status.ptr());
+  if (json_size == static_cast<size_t>(-1)) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("failed to dump proto to JSON: ",
+                     upb_Status_ErrorMessage(status.ptr())));
+  }
+  void* buf = upb_Arena_Malloc(arena, json_size + 1);
+  upb_JsonEncode(plugin_config, msg_type, symtab, 0,
+                 reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
+  Json::Object rls_policy;
+  grpc_error_handle error = GRPC_ERROR_NONE;
+  rls_policy["routeLookupConfig"] =
+      Json::Parse(reinterpret_cast<char*>(buf), &error);
+  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  Json::Object cds_policy;
+  cds_policy["cds_experimental"] = Json::Object();
+  Json::Array child_policy;
+  child_policy.emplace_back(std::move(cds_policy));
+  rls_policy["childPolicy"] = std::move(child_policy);
+  rls_policy["childPolicyConfigTargetFieldName"] = "cluster";
+  Json::Object policy;
+  policy["rls_experimental"] = std::move(rls_policy);
+  Json::Array policies;
+  policies.emplace_back(std::move(policy));
+  Json lb_policy_config(std::move(policies));
+  grpc_error_handle parse_error = GRPC_ERROR_NONE;
+  // TODO(roth): If/when we ever add a second plugin, refactor this code
+  // somehow such that we automatically validate the resulting config against
+  // the gRPC LB policy registry instead of requiring each plugin to do that
+  // itself.
+  LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(lb_policy_config,
+                                                        &parse_error);
+  if (parse_error != GRPC_ERROR_NONE) {
+    absl::Status status = absl::InvalidArgumentError(absl::StrCat(
+        kXdsRouteLookupClusterSpecifierPluginConfigName,
+        " ClusterSpecifierPlugin returned invalid LB policy config: ",
+        grpc_error_std_string(parse_error)));
+    GRPC_ERROR_UNREF(parse_error);
+    return status;
+  }
+  return lb_policy_config.Dump();
+}
+
+namespace {
+
+using PluginRegistryMap =
+    std::map<absl::string_view, std::unique_ptr<XdsClusterSpecifierPluginImpl>>;
+
+PluginRegistryMap* g_plugin_registry = nullptr;
+
+}  // namespace
+
+const XdsClusterSpecifierPluginImpl*
+XdsClusterSpecifierPluginRegistry::GetPluginForType(
+    absl::string_view config_proto_type_name) {
+  auto it = g_plugin_registry->find(config_proto_type_name);
+  if (it == g_plugin_registry->end()) return nullptr;
+  return it->second.get();
+}
+
+void XdsClusterSpecifierPluginRegistry::PopulateSymtab(upb_DefPool* symtab) {
+  for (const auto& p : *g_plugin_registry) {
+    p.second->PopulateSymtab(symtab);
+  }
+}
+
+void XdsClusterSpecifierPluginRegistry::RegisterPlugin(
+    std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin,
+    absl::string_view config_proto_type_name) {
+  (*g_plugin_registry)[config_proto_type_name] = std::move(plugin);
+}
+
+void XdsClusterSpecifierPluginRegistry::Init() {
+  g_plugin_registry = new PluginRegistryMap;
+  RegisterPlugin(absl::make_unique<XdsRouteLookupClusterSpecifierPlugin>(),
+                 kXdsRouteLookupClusterSpecifierPluginConfigName);
+}
+
+void XdsClusterSpecifierPluginRegistry::Shutdown() { delete g_plugin_registry; }
+
+}  // namespace grpc_core

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

@@ -0,0 +1,79 @@
+//
+// 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_CLUSTER_SPECIFIER_PLUGIN_H
+#define GRPC_CORE_EXT_XDS_XDS_CLUSTER_SPECIFIER_PLUGIN_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <set>
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "google/protobuf/any.upb.h"
+#include "upb/def.h"
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+class XdsClusterSpecifierPluginImpl {
+ public:
+  virtual ~XdsClusterSpecifierPluginImpl() = default;
+
+  // Loads the proto message into the upb symtab.
+  virtual void PopulateSymtab(upb_DefPool* symtab) const = 0;
+
+  // Returns the LB policy config in JSON form.
+  virtual absl::StatusOr<std::string> GenerateLoadBalancingPolicyConfig(
+      upb_StringView serialized_plugin_config, upb_Arena* arena,
+      upb_DefPool* symtab) const = 0;
+};
+
+class XdsRouteLookupClusterSpecifierPlugin
+    : public XdsClusterSpecifierPluginImpl {
+  void PopulateSymtab(upb_DefPool* symtab) const override;
+
+  absl::StatusOr<std::string> GenerateLoadBalancingPolicyConfig(
+      upb_StringView serialized_plugin_config, upb_Arena* arena,
+      upb_DefPool* symtab) const override;
+};
+
+class XdsClusterSpecifierPluginRegistry {
+ public:
+  static void RegisterPlugin(
+      std::unique_ptr<XdsClusterSpecifierPluginImpl> plugin,
+      absl::string_view config_proto_type_name);
+
+  static void PopulateSymtab(upb_DefPool* symtab);
+
+  static const XdsClusterSpecifierPluginImpl* GetPluginForType(
+      absl::string_view config_proto_type_name);
+
+  // Global init and shutdown.
+  static void Init();
+  static void Shutdown();
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_XDS_XDS_CLUSTER_SPECIFIER_PLUGIN_H

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

@@ -365,23 +365,23 @@ grpc_error_handle CommonTlsContext::Parse(
                                        &errors);
 }
 
-grpc_error_handle ExtractHttpFilterTypeName(const XdsEncodingContext& context,
-                                            const google_protobuf_Any* any,
-                                            absl::string_view* filter_type) {
-  *filter_type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
-  if (*filter_type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
-      *filter_type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
+grpc_error_handle ExtractExtensionTypeName(const XdsEncodingContext& context,
+                                           const google_protobuf_Any* any,
+                                           absl::string_view* extension_type) {
+  *extension_type = UpbStringToAbsl(google_protobuf_Any_type_url(any));
+  if (*extension_type == "type.googleapis.com/xds.type.v3.TypedStruct" ||
+      *extension_type == "type.googleapis.com/udpa.type.v1.TypedStruct") {
     upb_StringView any_value = google_protobuf_Any_value(any);
     const auto* typed_struct = xds_type_v3_TypedStruct_parse(
         any_value.data, any_value.size, context.arena);
     if (typed_struct == nullptr) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "could not parse TypedStruct from filter config");
+          "could not parse TypedStruct from extension");
     }
-    *filter_type =
+    *extension_type =
         UpbStringToAbsl(xds_type_v3_TypedStruct_type_url(typed_struct));
   }
-  *filter_type = absl::StripPrefix(*filter_type, "type.googleapis.com/");
+  *extension_type = absl::StripPrefix(*extension_type, "type.googleapis.com/");
   return GRPC_ERROR_NONE;
 }
 

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

@@ -86,9 +86,9 @@ struct CommonTlsContext {
       CommonTlsContext* common_tls_context);
 };
 
-grpc_error_handle ExtractHttpFilterTypeName(const XdsEncodingContext& context,
-                                            const google_protobuf_Any* any,
-                                            absl::string_view* filter_type);
+grpc_error_handle ExtractExtensionTypeName(const XdsEncodingContext& context,
+                                           const google_protobuf_Any* any,
+                                           absl::string_view* extension_type);
 
 }  // namespace grpc_core
 

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

@@ -202,7 +202,7 @@ grpc_error_handle LocalityParse(
   std::string region =
       UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
   std::string zone =
-      UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
+      UpbStringToStdString(envoy_config_core_v3_Locality_zone(locality));
   std::string sub_zone =
       UpbStringToStdString(envoy_config_core_v3_Locality_sub_zone(locality));
   output_locality->name = MakeRefCounted<XdsLocalityName>(
@@ -285,11 +285,18 @@ grpc_error_handle EdsResourceParse(
     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();
+    if (eds_update->priorities.size() < priority + 1) {
+      eds_update->priorities.resize(priority + 1);
+    }
+    auto& locality_map = eds_update->priorities[priority].localities;
+    auto it = locality_map.find(locality.name.get());
+    if (it != locality_map.end()) {
+      errors.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+          "duplicate locality ", locality.name->AsHumanReadableString(),
+          " found in priority ", priority)));
+    } else {
+      locality_map.emplace(locality.name.get(), std::move(locality));
     }
-    eds_update->priorities[priority].localities.emplace(locality.name.get(),
-                                                        std::move(locality));
   }
   for (const auto& priority : eds_update->priorities) {
     if (priority.localities.empty()) {

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

@@ -36,6 +36,7 @@
 #include <grpc/grpc.h>
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
+#include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -140,9 +141,8 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
         envoy_extensions_filters_common_fault_v3_FaultDelay_fixed_delay(
             fault_delay);
     if (delay_duration != nullptr) {
-      fault_injection_policy_json["delay"] = absl::StrFormat(
-          "%d.%09ds", google_protobuf_Duration_seconds(delay_duration),
-          google_protobuf_Duration_nanos(delay_duration));
+      fault_injection_policy_json["delay"] =
+          ParseDuration(delay_duration).ToJsonString();
     }
     // Set the headers if we enabled header delay injection control
     if (envoy_extensions_filters_common_fault_v3_FaultDelay_has_header_delay(
@@ -198,7 +198,7 @@ XdsHttpFaultFilter::GenerateFilterConfigOverride(
 }
 
 const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
-  return &FaultInjectionFilterVtable;
+  return &FaultInjectionFilter::kFilter;
 }
 
 grpc_channel_args* XdsHttpFaultFilter::ModifyChannelArgs(

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

@@ -109,8 +109,10 @@ std::string XdsListenerResource::FilterChainData::ToString() const {
 //
 
 std::string XdsListenerResource::FilterChainMap::CidrRange::ToString() const {
+  auto addr_str = grpc_sockaddr_to_string(&address, false);
   return absl::StrCat(
-      "{address_prefix=", grpc_sockaddr_to_string(&address, false),
+      "{address_prefix=",
+      addr_str.ok() ? addr_str.value() : addr_str.status().ToString(),
       ", prefix_len=", prefix_len, "}");
 }
 
@@ -332,7 +334,7 @@ grpc_error_handle HttpConnectionManagerParse(
       }
       absl::string_view filter_type;
       grpc_error_handle error =
-          ExtractHttpFilterTypeName(context, any, &filter_type);
+          ExtractExtensionTypeName(context, any, &filter_type);
       if (error != GRPC_ERROR_NONE) return error;
       const XdsHttpFilterImpl* filter_impl =
           XdsHttpFilterRegistry::GetFilterForType(filter_type);
@@ -776,9 +778,12 @@ grpc_error_handle AddFilterChainDataForSourceIpRange(
   } else {
     for (const auto& prefix_range :
          filter_chain.filter_chain_match.source_prefix_ranges) {
+      auto addr_str = grpc_sockaddr_to_string(&prefix_range.address, false);
+      if (!addr_str.ok()) {
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+      }
       auto insert_result = source_ip_map->emplace(
-          absl::StrCat(grpc_sockaddr_to_string(&prefix_range.address, false),
-                       "/", prefix_range.prefix_len),
+          absl::StrCat(*addr_str, "/", prefix_range.prefix_len),
           XdsListenerResource::FilterChainMap::SourceIp());
       if (insert_result.second) {
         insert_result.first->second.prefix_range.emplace(prefix_range);
@@ -860,9 +865,12 @@ grpc_error_handle AddFilterChainDataForDestinationIpRange(
   } else {
     for (const auto& prefix_range :
          filter_chain.filter_chain_match.prefix_ranges) {
+      auto addr_str = grpc_sockaddr_to_string(&prefix_range.address, false);
+      if (!addr_str.ok()) {
+        return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+      }
       auto insert_result = destination_ip_map->emplace(
-          absl::StrCat(grpc_sockaddr_to_string(&prefix_range.address, false),
-                       "/", prefix_range.prefix_len),
+          absl::StrCat(*addr_str, "/", prefix_range.prefix_len),
           InternalFilterChainMap::DestinationIp());
       if (insert_result.second) {
         insert_result.first->second.prefix_range.emplace(prefix_range);
@@ -968,10 +976,12 @@ grpc_error_handle LdsResourceParse(
       envoy_config_listener_v3_Listener_api_listener(listener);
   const envoy_config_core_v3_Address* address =
       envoy_config_listener_v3_Listener_address(listener);
-  if (api_listener != nullptr && address != nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Listener has both address and ApiListener");
-  }
+  // TODO(roth): Re-enable the following check once
+  // github.com/istio/istio/issues/38914 is resolved.
+  // if (api_listener != nullptr && address != nullptr) {
+  //   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+  //       "Listener has both address and ApiListener");
+  // }
   if (api_listener == nullptr && address == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Listener has neither address nor ApiListener");