grpc 1.35.0.pre1 → 1.37.1

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

@@ -88,6 +88,12 @@ class XdsClient : public DualRefCounted<XdsClient> {
   explicit XdsClient(grpc_error** error);
   ~XdsClient() override;
 
+  const XdsBootstrap& bootstrap() const {
+    // bootstrap_ is guaranteed to be non-null since XdsClient::GetOrCreate()
+    // would return a null object if bootstrap_ was null.
+    return *bootstrap_;
+  }
+
   CertificateProviderStore& certificate_provider_store() {
     return *certificate_provider_store_;
   }
@@ -185,6 +191,15 @@ class XdsClient : public DualRefCounted<XdsClient> {
   // Resets connection backoff state.
   void ResetBackoff();
 
+  // Dumps the active xDS config in JSON format.
+  // Individual xDS resource is encoded as envoy.admin.v3.*ConfigDump. Returns
+  // envoy.service.status.v3.ClientConfig which also includes the config
+  // status (e.g., CLIENT_REQUESTED, CLIENT_ACKED, CLIENT_NACKED).
+  //
+  // Expected to be invoked by wrapper languages in their CSDS service
+  // implementation.
+  std::string DumpClientConfigBinary();
+
  private:
   // Contains a channel to the xds server and all the data related to the
   // channel.  Holds a ref to the xds client object.
@@ -215,6 +230,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
     void MaybeStartLrsCall();
     void StopLrsCall();
 
+    bool HasAdsCall() const;
     bool HasActiveAdsCall() const;
 
     void StartConnectivityWatchLocked();
@@ -248,6 +264,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
         watchers;
     // The latest data seen from LDS.
     absl::optional<XdsApi::LdsUpdate> update;
+    XdsApi::ResourceMetadata meta;
   };
 
   struct RouteConfigState {
@@ -256,6 +273,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
         watchers;
     // The latest data seen from RDS.
     absl::optional<XdsApi::RdsUpdate> update;
+    XdsApi::ResourceMetadata meta;
   };
 
   struct ClusterState {
@@ -263,6 +281,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
         watchers;
     // The latest data seen from CDS.
     absl::optional<XdsApi::CdsUpdate> update;
+    XdsApi::ResourceMetadata meta;
   };
 
   struct EndpointState {
@@ -271,6 +290,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
         watchers;
     // The latest data seen from EDS.
     absl::optional<XdsApi::EdsUpdate> update;
+    XdsApi::ResourceMetadata meta;
   };
 
   struct LoadReportState {
@@ -293,6 +313,12 @@ class XdsClient : public DualRefCounted<XdsClient> {
   XdsApi::ClusterLoadReportMap BuildLoadReportSnapshotLocked(
       bool send_all_clusters, const std::set<std::string>& clusters);
 
+  void UpdateResourceMetadataWithFailedParseResult(
+      grpc_millis update_time, const XdsApi::AdsParseResult& result);
+  void UpdatePendingResources(
+      const std::string& type_url,
+      XdsApi::ResourceMetadataMap* resource_metadata_map);
+
   const grpc_millis request_timeout_;
   grpc_pollset_set* interested_parties_;
   std::unique_ptr<XdsBootstrap> bootstrap_;
@@ -329,6 +355,9 @@ class XdsClient : public DualRefCounted<XdsClient> {
 namespace internal {
 void SetXdsChannelArgsForTest(grpc_channel_args* args);
 void UnsetGlobalXdsClientForTest();
+// Sets bootstrap config to be used when no env var is set.
+// Does not take ownership of config.
+void SetXdsFallbackBootstrapConfig(const char* config);
 }  // namespace internal
 
 }  // namespace grpc_core

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

@@ -137,7 +137,8 @@ XdsClusterLocalityStats::GetSnapshotAndReset() {
                        // not related to a single reporting interval.
                        total_requests_in_progress_.Load(MemoryOrder::RELAXED),
                        GetAndResetCounter(&total_error_requests_),
-                       GetAndResetCounter(&total_issued_requests_)};
+                       GetAndResetCounter(&total_issued_requests_),
+                       {}};
   MutexLock lock(&backend_metrics_mu_);
   snapshot.backend_metrics = std::move(backend_metrics_);
   return snapshot;

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