grpc 1.36.0 → 1.37.0.pre1

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

@@ -56,10 +56,10 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
     }
   };
 
-  XdsLocalityName(std::string region, std::string zone, std::string subzone)
+  XdsLocalityName(std::string region, std::string zone, std::string sub_zone)
       : region_(std::move(region)),
         zone_(std::move(zone)),
-        sub_zone_(std::move(subzone)) {}
+        sub_zone_(std::move(sub_zone)) {}
 
   bool operator==(const XdsLocalityName& other) const {
     return region_ == other.region_ && zone_ == other.zone_ &&

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

@@ -0,0 +1,226 @@
+//
+// Copyright 2021 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_http_fault_filter.h"
+
+#include <grpc/grpc.h>
+
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "envoy/extensions/filters/common/fault/v3/fault.upb.h"
+#include "envoy/extensions/filters/http/fault/v3/fault.upb.h"
+#include "envoy/extensions/filters/http/fault/v3/fault.upbdefs.h"
+#include "envoy/type/v3/percent.upb.h"
+#include "google/protobuf/any.upb.h"
+#include "google/protobuf/duration.upb.h"
+#include "google/protobuf/wrappers.upb.h"
+#include "src/core/ext/filters/fault_injection/fault_injection_filter.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"
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/transport/status_conversion.h"
+#include "upb/def.h"
+
+namespace grpc_core {
+
+const char* kXdsHttpFaultFilterConfigName =
+    "envoy.extensions.filters.http.fault.v3.HTTPFault";
+
+namespace {
+
+uint32_t GetDenominator(const envoy_type_v3_FractionalPercent* fraction) {
+  if (fraction != nullptr) {
+    const auto denominator =
+        static_cast<envoy_type_v3_FractionalPercent_DenominatorType>(
+            envoy_type_v3_FractionalPercent_denominator(fraction));
+    switch (denominator) {
+      case envoy_type_v3_FractionalPercent_MILLION:
+        return 1000000;
+      case envoy_type_v3_FractionalPercent_TEN_THOUSAND:
+        return 10000;
+      case envoy_type_v3_FractionalPercent_HUNDRED:
+      default:
+        return 100;
+    }
+  }
+  // Use 100 as the default denominator
+  return 100;
+}
+
+absl::StatusOr<Json> ParseHttpFaultIntoJson(upb_strview 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) {
+    return absl::InvalidArgumentError(
+        "could not parse fault injection filter config");
+  }
+  // NOTE(lidiz): Here, we are manually translating the upb messages into the
+  // JSON form of the filter config as part of method config, which will be
+  // directly used later by service config. In this way, we can validate the
+  // filter configs, and NACK if needed. It also allows the service config to
+  // function independently without xDS, but not the other way around.
+  // NOTE(lidiz): please refer to FaultInjectionPolicy for ground truth
+  // definitions, located at:
+  // src/core/ext/filters/fault_injection/service_config_parser.h
+  Json::Object fault_injection_policy_json;
+  // Section 1: Parse the abort injection config
+  const auto* fault_abort =
+      envoy_extensions_filters_http_fault_v3_HTTPFault_abort(http_fault);
+  if (fault_abort != nullptr) {
+    grpc_status_code abort_grpc_status_code = GRPC_STATUS_OK;
+    // Try if gRPC status code is set first
+    int abort_grpc_status_code_raw =
+        envoy_extensions_filters_http_fault_v3_FaultAbort_grpc_status(
+            fault_abort);
+    if (abort_grpc_status_code_raw != 0) {
+      if (!grpc_status_code_from_int(abort_grpc_status_code_raw,
+                                     &abort_grpc_status_code)) {
+        return absl::InvalidArgumentError(absl::StrCat(
+            "invalid gRPC status code: ", abort_grpc_status_code_raw));
+      }
+    } else {
+      // if gRPC status code is empty, check http status
+      int abort_http_status_code =
+          envoy_extensions_filters_http_fault_v3_FaultAbort_http_status(
+              fault_abort);
+      if (abort_http_status_code != 0 and abort_http_status_code != 200) {
+        abort_grpc_status_code =
+            grpc_http2_status_to_grpc_status(abort_http_status_code);
+      }
+    }
+    // Set the abort_code, even if it's OK
+    fault_injection_policy_json["abortCode"] =
+        grpc_status_code_to_string(abort_grpc_status_code);
+    // Set the headers if we enabled header abort injection control
+    if (envoy_extensions_filters_http_fault_v3_FaultAbort_has_header_abort(
+            fault_abort)) {
+      fault_injection_policy_json["abortCodeHeader"] =
+          "x-envoy-fault-abort-grpc-request";
+      fault_injection_policy_json["abortPercentageHeader"] =
+          "x-envoy-fault-abort-percentage";
+    }
+    // Set the fraction percent
+    auto* percent =
+        envoy_extensions_filters_http_fault_v3_FaultAbort_percentage(
+            fault_abort);
+    fault_injection_policy_json["abortPercentageNumerator"] =
+        Json(envoy_type_v3_FractionalPercent_numerator(percent));
+    fault_injection_policy_json["abortPercentageDenominator"] =
+        Json(GetDenominator(percent));
+  }
+  // Section 2: Parse the delay injection config
+  const auto* fault_delay =
+      envoy_extensions_filters_http_fault_v3_HTTPFault_delay(http_fault);
+  if (fault_delay != nullptr) {
+    // Parse the delay duration
+    const auto* delay_duration =
+        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));
+    }
+    // Set the headers if we enabled header delay injection control
+    if (envoy_extensions_filters_common_fault_v3_FaultDelay_has_header_delay(
+            fault_delay)) {
+      fault_injection_policy_json["delayHeader"] =
+          "x-envoy-fault-delay-request";
+      fault_injection_policy_json["delayPercentageHeader"] =
+          "x-envoy-fault-delay-request-percentage";
+    }
+    // Set the fraction percent
+    auto* percent =
+        envoy_extensions_filters_common_fault_v3_FaultDelay_percentage(
+            fault_delay);
+    fault_injection_policy_json["delayPercentageNumerator"] =
+        Json(envoy_type_v3_FractionalPercent_numerator(percent));
+    fault_injection_policy_json["delayPercentageDenominator"] =
+        Json(GetDenominator(percent));
+  }
+  // Section 3: Parse the maximum active faults
+  const auto* max_fault_wrapper =
+      envoy_extensions_filters_http_fault_v3_HTTPFault_max_active_faults(
+          http_fault);
+  if (max_fault_wrapper != nullptr) {
+    fault_injection_policy_json["maxFaults"] =
+        google_protobuf_UInt32Value_value(max_fault_wrapper);
+  }
+  return fault_injection_policy_json;
+}
+
+}  // namespace
+
+void XdsHttpFaultFilter::PopulateSymtab(upb_symtab* 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 {
+  absl::StatusOr<Json> parse_result =
+      ParseHttpFaultIntoJson(serialized_filter_config, arena);
+  if (!parse_result.ok()) {
+    return parse_result.status();
+  }
+  return FilterConfig{kXdsHttpFaultFilterConfigName, std::move(*parse_result)};
+}
+
+absl::StatusOr<XdsHttpFilterImpl::FilterConfig>
+XdsHttpFaultFilter::GenerateFilterConfigOverride(
+    upb_strview 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);
+}
+
+const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
+  return &FaultInjectionFilterVtable;
+}
+
+grpc_channel_args* XdsHttpFaultFilter::ModifyChannelArgs(
+    grpc_channel_args* args) const {
+  grpc_arg args_to_add = grpc_channel_arg_integer_create(
+      const_cast<char*>(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG), 1);
+  grpc_channel_args* new_args =
+      grpc_channel_args_copy_and_add(args, &args_to_add, 1);
+  // Since this function takes the ownership of the channel args, it needs to
+  // deallocate the old ones to prevent leak.
+  grpc_channel_args_destroy(args);
+  return new_args;
+}
+
+absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
+XdsHttpFaultFilter::GenerateServiceConfig(
+    const FilterConfig& hcm_filter_config,
+    const FilterConfig* filter_config_override) const {
+  Json policy_json = filter_config_override != nullptr
+                         ? filter_config_override->config
+                         : hcm_filter_config.config;
+  // The policy JSON may be empty, that's allowed.
+  return ServiceConfigJsonEntry{"faultInjectionPolicy", policy_json.Dump()};
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,63 @@
+//
+// Copyright 2021 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_HTTP_FAULT_FILTER_H
+#define GRPC_CORE_EXT_XDS_XDS_HTTP_FAULT_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/grpc.h>
+
+#include "absl/status/statusor.h"
+#include "src/core/ext/xds/xds_http_filters.h"
+#include "upb/def.h"
+
+namespace grpc_core {
+
+extern const char* kXdsHttpFaultFilterConfigName;
+
+class XdsHttpFaultFilter : public XdsHttpFilterImpl {
+ public:
+  // Overrides the PopulateSymtab method
+  void PopulateSymtab(upb_symtab* symtab) const override;
+
+  // Overrides the GenerateFilterConfig method
+  absl::StatusOr<FilterConfig> GenerateFilterConfig(
+      upb_strview 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;
+
+  // Overrides the channel_filter method
+  const grpc_channel_filter* channel_filter() const override;
+
+  // Overrides the ModifyChannelArgs method
+  grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) const override;
+
+  // Overrides the GenerateServiceConfig method
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& hcm_filter_config,
+      const FilterConfig* filter_config_override) const override;
+
+  bool IsSupportedOnClients() const override { return true; }
+
+  bool IsSupportedOnServers() const override { return false; }
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_XDS_XDS_HTTP_FAULT_FILTER_H */

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

@@ -0,0 +1,114 @@
+//
+// Copyright 2021 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_http_filters.h"
+
+#include "envoy/extensions/filters/http/router/v3/router.upb.h"
+#include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
+#include "src/core/ext/xds/xds_http_fault_filter.h"
+
+namespace grpc_core {
+
+const char* kXdsHttpRouterFilterConfigName =
+    "envoy.extensions.filters.http.router.v3.Router";
+
+namespace {
+
+class XdsHttpRouterFilter : public XdsHttpFilterImpl {
+ public:
+  void PopulateSymtab(upb_symtab* 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 {
+    if (envoy_extensions_filters_http_router_v3_Router_parse(
+            serialized_filter_config.data, serialized_filter_config.size,
+            arena) == nullptr) {
+      return absl::InvalidArgumentError("could not parse router filter config");
+    }
+    return FilterConfig{kXdsHttpRouterFilterConfigName, Json()};
+  }
+
+  absl::StatusOr<FilterConfig> GenerateFilterConfigOverride(
+      upb_strview /*serialized_filter_config*/,
+      upb_arena* /*arena*/) const override {
+    return absl::InvalidArgumentError(
+        "router filter does not support config override");
+  }
+
+  // No-op -- this filter is special-cased by the xds resolver.
+  const grpc_channel_filter* channel_filter() const override { return nullptr; }
+
+  // No-op -- this filter is special-cased by the xds resolver.
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& /*hcm_filter_config*/,
+      const FilterConfig* /*filter_config_override*/) const override {
+    return absl::UnimplementedError("router filter should never be called");
+  }
+
+  bool IsSupportedOnClients() const override { return true; }
+
+  bool IsSupportedOnServers() const override { return true; }
+};
+
+using FilterOwnerList = std::vector<std::unique_ptr<XdsHttpFilterImpl>>;
+using FilterRegistryMap = std::map<absl::string_view, XdsHttpFilterImpl*>;
+
+FilterOwnerList* g_filters = nullptr;
+FilterRegistryMap* g_filter_registry = nullptr;
+
+}  // namespace
+
+void XdsHttpFilterRegistry::RegisterFilter(
+    std::unique_ptr<XdsHttpFilterImpl> filter,
+    const std::set<absl::string_view>& config_proto_type_names) {
+  for (auto config_proto_type_name : config_proto_type_names) {
+    (*g_filter_registry)[config_proto_type_name] = filter.get();
+  }
+  g_filters->push_back(std::move(filter));
+}
+
+const XdsHttpFilterImpl* XdsHttpFilterRegistry::GetFilterForType(
+    absl::string_view proto_type_name) {
+  auto it = g_filter_registry->find(proto_type_name);
+  if (it == g_filter_registry->end()) return nullptr;
+  return it->second;
+}
+
+void XdsHttpFilterRegistry::PopulateSymtab(upb_symtab* symtab) {
+  for (const auto& filter : *g_filters) {
+    filter->PopulateSymtab(symtab);
+  }
+}
+
+void XdsHttpFilterRegistry::Init() {
+  g_filters = new FilterOwnerList;
+  g_filter_registry = new FilterRegistryMap;
+  RegisterFilter(absl::make_unique<XdsHttpRouterFilter>(),
+                 {kXdsHttpRouterFilterConfigName});
+  RegisterFilter(absl::make_unique<XdsHttpFaultFilter>(),
+                 {kXdsHttpFaultFilterConfigName});
+}
+
+void XdsHttpFilterRegistry::Shutdown() {
+  delete g_filter_registry;
+  delete g_filters;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,130 @@
+//
+// Copyright 2021 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_HTTP_FILTERS_H
+#define GRPC_CORE_EXT_XDS_XDS_HTTP_FILTERS_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 {
+
+extern const char* kXdsHttpRouterFilterConfigName;
+
+class XdsHttpFilterImpl {
+ public:
+  struct FilterConfig {
+    absl::string_view config_proto_type_name;
+    Json config;
+
+    bool operator==(const FilterConfig& other) const {
+      return config_proto_type_name == other.config_proto_type_name &&
+             config == other.config;
+    }
+    std::string ToString() const {
+      return absl::StrCat("{config_proto_type_name=", config_proto_type_name,
+                          " config=", config.Dump(), "}");
+    }
+  };
+
+  // Service config data for the filter, returned by GenerateServiceConfig().
+  struct ServiceConfigJsonEntry {
+    // The top-level field name in the method config.
+    // Filter implementations should use their primary config proto type
+    // name for this.
+    // The value of this field in the method config will be a JSON array,
+    // which will be populated with the elements returned by each filter
+    // instance.
+    std::string service_config_field_name;
+    // The element to add to the JSON array.
+    std::string element;
+  };
+
+  virtual ~XdsHttpFilterImpl() = default;
+
+  // Loads the proto message into the upb symtab.
+  virtual void PopulateSymtab(upb_symtab* 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;
+
+  // 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;
+
+  // C-core channel filter implementation.
+  virtual const grpc_channel_filter* channel_filter() const = 0;
+
+  // Modifies channel args that may affect service config parsing (not
+  // visible to the channel as a whole).
+  // Takes ownership of args.  Caller takes ownership of return value.
+  virtual grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) const {
+    return args;
+  }
+
+  // Function to convert the Configs into a JSON string to be added to the
+  // per-method part of the service config.
+  // The hcm_filter_config comes from the HttpConnectionManager config.
+  // The filter_config_override comes from the first of the ClusterWeight,
+  // Route, or VirtualHost entries that it is found in, or null if
+  // there is no override in any of those locations.
+  virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& hcm_filter_config,
+      const FilterConfig* filter_config_override) const = 0;
+
+  // Returns true if the filter is supported on clients; false otherwise
+  virtual bool IsSupportedOnClients() const = 0;
+
+  // Returns true if the filter is supported on servers; false otherwise
+  virtual bool IsSupportedOnServers() const = 0;
+};
+
+class XdsHttpFilterRegistry {
+ public:
+  static void RegisterFilter(
+      std::unique_ptr<XdsHttpFilterImpl> filter,
+      const std::set<absl::string_view>& config_proto_type_names);
+
+  static const XdsHttpFilterImpl* GetFilterForType(
+      absl::string_view proto_type_name);
+
+  static void PopulateSymtab(upb_symtab* symtab);
+
+  // Global init and shutdown.
+  static void Init();
+  static void Shutdown();
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_XDS_XDS_HTTP_FILTERS_H */