grpc 1.39.0 → 1.40.0.pre1

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

@@ -38,6 +38,7 @@
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
@@ -109,10 +110,34 @@ class XdsApi {
       bool operator==(const HashPolicy& other) const;
       std::string ToString() const;
     };
-
     Matchers matchers;
     std::vector<HashPolicy> hash_policies;
 
+    struct RetryPolicy {
+      internal::StatusCodeSet retry_on;
+      uint32_t num_retries;
+
+      struct RetryBackOff {
+        Duration base_interval;
+        Duration max_interval;
+
+        bool operator==(const RetryBackOff& other) const {
+          return base_interval == other.base_interval &&
+                 max_interval == other.max_interval;
+        }
+        std::string ToString() const;
+      };
+      RetryBackOff retry_back_off;
+
+      bool operator==(const RetryPolicy& other) const {
+        return (retry_on == other.retry_on &&
+                num_retries == other.num_retries &&
+                retry_back_off == other.retry_back_off);
+      }
+      std::string ToString() const;
+    };
+    absl::optional<RetryPolicy> retry_policy;
+
     // Action for this route.
     // TODO(roth): When we can use absl::variant<>, consider using that
     // here, to enforce the fact that only one of the two fields can be set.
@@ -139,6 +164,7 @@ class XdsApi {
 
     bool operator==(const Route& other) const {
       return matchers == other.matchers && cluster_name == other.cluster_name &&
+             retry_policy == other.retry_policy &&
              weighted_clusters == other.weighted_clusters &&
              max_stream_duration == other.max_stream_duration &&
              typed_per_filter_config == other.typed_per_filter_config;
@@ -628,7 +654,8 @@ class XdsApi {
     std::set<std::string> resource_names_failed;
   };
 
-  XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node);
+  XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node,
+         const CertificateProviderStore::PluginDefinitionMap* map);
 
   // Creates an ADS request.
   // Takes ownership of \a error.
@@ -669,6 +696,8 @@ class XdsApi {
   XdsClient* client_;
   TraceFlag* tracer_;
   const XdsBootstrap::Node* node_;  // Do not own.
+  const CertificateProviderStore::PluginDefinitionMap*
+      certificate_provider_definition_map_;  // Do not own.
   upb::SymbolTable symtab_;
   const std::string build_version_;
   const std::string user_agent_name_;

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

@@ -403,7 +403,10 @@ grpc_error_handle XdsBootstrap::ParseCertificateProvider(
     CertificateProviderFactory* factory =
         CertificateProviderRegistry::LookupCertificateProviderFactory(
             plugin_name);
-    if (factory != nullptr) {
+    if (factory == nullptr) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("Unrecognized plugin name: ", plugin_name).c_str()));
+    } else {
       RefCountedPtr<CertificateProviderFactory::Config> config;
       it = certificate_provider_json->mutable_object()->find("config");
       if (it != certificate_provider_json->mutable_object()->end()) {

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

@@ -275,6 +275,12 @@ class XdsClient::ChannelState::AdsCallState
                              XdsApi::EdsUpdateMap eds_update_map)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
+  template <typename StateMap>
+  void RejectAdsUpdateLocked(grpc_millis update_time,
+                             const XdsApi::AdsParseResult& result,
+                             StateMap* state_map)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
+
   static void OnRequestSent(void* arg, grpc_error_handle error);
   void OnRequestSentLocked(grpc_error_handle error)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
@@ -1145,6 +1151,47 @@ void XdsClient::ChannelState::AdsCallState::AcceptEdsUpdateLocked(
   }
 }
 
+namespace {
+
+// Update resource_metadata for NACK.
+void UpdateResourceMetadataNacked(const std::string& version,
+                                  const std::string& details,
+                                  grpc_millis update_time,
+                                  XdsApi::ResourceMetadata* resource_metadata) {
+  resource_metadata->client_status = XdsApi::ResourceMetadata::NACKED;
+  resource_metadata->failed_version = version;
+  resource_metadata->failed_details = details;
+  resource_metadata->failed_update_time = update_time;
+}
+
+}  // namespace
+
+template <typename StateMap>
+void XdsClient::ChannelState::AdsCallState::RejectAdsUpdateLocked(
+    grpc_millis update_time, const XdsApi::AdsParseResult& result,
+    StateMap* state_map) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_client %p] %s update NACKed containing %" PRIuPTR
+            " resources",
+            xds_client(), result.type_url.c_str(),
+            result.resource_names_failed.size());
+  }
+  std::string details = grpc_error_std_string(result.parse_error);
+  for (auto& name : result.resource_names_failed) {
+    auto it = state_map->find(name);
+    if (it == state_map->end()) continue;
+    auto& state = it->second;
+    // Notify watchers of error.
+    for (const auto& p : state.watchers) {
+      p.first->OnError(GRPC_ERROR_REF(result.parse_error));
+    }
+    // Update resource metadata for CSDS.
+    UpdateResourceMetadataNacked(result.version, details, update_time,
+                                 &state.meta);
+  }
+}
+
 void XdsClient::ChannelState::AdsCallState::OnRequestSent(
     void* arg, grpc_error_handle error) {
   AdsCallState* ads_calld = static_cast<AdsCallState*>(arg);
@@ -1223,10 +1270,6 @@ bool XdsClient::ChannelState::AdsCallState::OnResponseReceivedLocked() {
     state.nonce = std::move(result.nonce);
     // NACK or ACK the response.
     if (result.parse_error != GRPC_ERROR_NONE) {
-      xds_client()->UpdateResourceMetadataWithFailedParseResultLocked(
-          update_time, result);
-      GRPC_ERROR_UNREF(state.error);
-      state.error = result.parse_error;
       // NACK unacceptable update.
       gpr_log(GPR_ERROR,
               "[xds_client %p] ADS response invalid for resource type %s "
@@ -1234,6 +1277,23 @@ bool XdsClient::ChannelState::AdsCallState::OnResponseReceivedLocked() {
               xds_client(), result.type_url.c_str(), result.version.c_str(),
               state.nonce.c_str(),
               grpc_error_std_string(result.parse_error).c_str());
+      result.parse_error =
+          grpc_error_set_int(result.parse_error, GRPC_ERROR_INT_GRPC_STATUS,
+                             GRPC_STATUS_UNAVAILABLE);
+      GRPC_ERROR_UNREF(state.error);
+      state.error = result.parse_error;
+      if (result.type_url == XdsApi::kLdsTypeUrl) {
+        RejectAdsUpdateLocked(update_time, result,
+                              &xds_client()->listener_map_);
+      } else if (result.type_url == XdsApi::kRdsTypeUrl) {
+        RejectAdsUpdateLocked(update_time, result,
+                              &xds_client()->route_config_map_);
+      } else if (result.type_url == XdsApi::kCdsTypeUrl) {
+        RejectAdsUpdateLocked(update_time, result, &xds_client()->cluster_map_);
+      } else if (result.type_url == XdsApi::kEdsTypeUrl) {
+        RejectAdsUpdateLocked(update_time, result,
+                              &xds_client()->endpoint_map_);
+      }
       SendMessageLocked(result.type_url);
     } else {
       seen_response_ = true;
@@ -1803,7 +1863,8 @@ XdsClient::XdsClient(std::unique_ptr<XdsBootstrap> bootstrap,
       interested_parties_(grpc_pollset_set_create()),
       certificate_provider_store_(MakeOrphanable<CertificateProviderStore>(
           bootstrap_->certificate_providers())),
-      api_(this, &grpc_xds_client_trace, bootstrap_->node()) {
+      api_(this, &grpc_xds_client_trace, bootstrap_->node(),
+           &bootstrap_->certificate_providers()) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO, "[xds_client %p] creating xds client", this);
   }
@@ -2252,44 +2313,6 @@ XdsApi::ClusterLoadReportMap XdsClient::BuildLoadReportSnapshotLocked(
   return snapshot_map;
 }
 
-void XdsClient::UpdateResourceMetadataWithFailedParseResultLocked(
-    grpc_millis update_time, const XdsApi::AdsParseResult& result) {
-  // ADS update is rejected and the resource names in the failed update is
-  // available.
-  std::string details = grpc_error_std_string(result.parse_error);
-  for (auto& name : result.resource_names_failed) {
-    XdsApi::ResourceMetadata* resource_metadata = nullptr;
-    if (result.type_url == XdsApi::kLdsTypeUrl) {
-      auto it = listener_map_.find(name);
-      if (it != listener_map_.end()) {
-        resource_metadata = &it->second.meta;
-      }
-    } else if (result.type_url == XdsApi::kRdsTypeUrl) {
-      auto it = route_config_map_.find(name);
-      if (route_config_map_.find(name) != route_config_map_.end()) {
-        resource_metadata = &it->second.meta;
-      }
-    } else if (result.type_url == XdsApi::kCdsTypeUrl) {
-      auto it = cluster_map_.find(name);
-      if (cluster_map_.find(name) != cluster_map_.end()) {
-        resource_metadata = &it->second.meta;
-      }
-    } else if (result.type_url == XdsApi::kEdsTypeUrl) {
-      auto it = endpoint_map_.find(name);
-      if (endpoint_map_.find(name) != endpoint_map_.end()) {
-        resource_metadata = &it->second.meta;
-      }
-    }
-    if (resource_metadata == nullptr) {
-      return;
-    }
-    resource_metadata->client_status = XdsApi::ResourceMetadata::NACKED;
-    resource_metadata->failed_version = result.version;
-    resource_metadata->failed_details = details;
-    resource_metadata->failed_update_time = update_time;
-  }
-}
-
 std::string XdsClient::DumpClientConfigBinary() {
   MutexLock lock(&mu_);
   XdsApi::ResourceTypeMetadataMap resource_type_metadata_map;

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

@@ -324,10 +324,6 @@ class XdsClient : public DualRefCounted<XdsClient> {
       bool send_all_clusters, const std::set<std::string>& clusters)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
-  void UpdateResourceMetadataWithFailedParseResultLocked(
-      grpc_millis update_time, const XdsApi::AdsParseResult& result)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
   std::unique_ptr<XdsBootstrap> bootstrap_;
   grpc_channel_args* args_;
   const grpc_millis request_timeout_;

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

@@ -52,10 +52,9 @@ class XdsHttpRouterFilter : public XdsHttpFilterImpl {
         "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.
+  // No-op.  This will never be called, since channel_filter() returns null.
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& /*hcm_filter_config*/,
       const FilterConfig* /*filter_config_override*/) const override {
@@ -65,6 +64,8 @@ class XdsHttpRouterFilter : public XdsHttpFilterImpl {
   bool IsSupportedOnClients() const override { return true; }
 
   bool IsSupportedOnServers() const override { return true; }
+
+  bool IsTerminalFilter() const override { return true; }
 };
 
 using FilterOwnerList = std::vector<std::unique_ptr<XdsHttpFilterImpl>>;

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

@@ -107,6 +107,9 @@ class XdsHttpFilterImpl {
 
   // Returns true if the filter is supported on servers; false otherwise
   virtual bool IsSupportedOnServers() const = 0;
+
+  // Returns true if the filter must be the last filter in the chain.
+  virtual bool IsTerminalFilter() const { return false; }
 };
 
 class XdsHttpFilterRegistry {

data/src/core/lib/channel/call_tracer.h

@@ -0,0 +1,85 @@
+//
+//
+// 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_LIB_CHANNEL_CALL_TRACER_H
+#define GRPC_CORE_LIB_CHANNEL_CALL_TRACER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+// Interface for a tracer that records activities on a call. Actual attempts for
+// this call are traced with CallAttemptTracer after invoking RecordNewAttempt()
+// on the CallTracer object.
+class CallTracer {
+ public:
+  // Interface for a tracer that records activities on a particular call
+  // attempt.
+  // (A single RPC can have multiple attempts due to retry/hedging policies or
+  // as transparent retry attempts.)
+  class CallAttemptTracer {
+   public:
+    virtual ~CallAttemptTracer() {}
+    // Please refer to `grpc_transport_stream_op_batch_payload` for details on
+    // arguments.
+    virtual void RecordSendInitialMetadata(
+        grpc_metadata_batch* send_initial_metadata, uint32_t flags) = 0;
+    // TODO(yashkt): We are using gpr_atm here instead of absl::string_view
+    // since that's what the transport API uses, and performing an atomic load
+    // is unnecessary if the census tracer does not need it at present. Fix this
+    // when the transport API changes.
+    virtual void RecordOnDoneSendInitialMetadata(gpr_atm* peer_string) = 0;
+    virtual void RecordSendTrailingMetadata(
+        grpc_metadata_batch* send_trailing_metadata) = 0;
+    virtual void RecordSendMessage(const ByteStream& send_message) = 0;
+    // The `RecordReceivedInitialMetadata()` and `RecordReceivedMessage()`
+    // methods should only be invoked when the metadata/message was
+    // successfully received, i.e., without any error.
+    virtual void RecordReceivedInitialMetadata(
+        grpc_metadata_batch* recv_initial_metadata, uint32_t flags) = 0;
+    virtual void RecordReceivedMessage(const ByteStream& recv_message) = 0;
+    virtual void RecordReceivedTrailingMetadata(
+        absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
+        const grpc_transport_stream_stats& transport_stream_stats) = 0;
+    virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
+    // Should be the last API call to the object. Once invoked, the tracer
+    // library is free to destroy the object.
+    virtual void RecordEnd(const gpr_timespec& latency) = 0;
+  };
+
+  virtual ~CallTracer() {}
+
+  // Records a new attempt for the associated call. \a transparent denotes
+  // whether the attempt is being made as a transparent retry or as a
+  // non-transparent retry/heding attempt. (There will be at least one attempt
+  // even if the call is not being retried.) The `CallTracer` object retains
+  // ownership to the newly created `CallAttemptTracer` object. RecordEnd()
+  // serves as an indication that the call stack is done with all API calls, and
+  // the tracer library is free to destroy it after that.
+  virtual CallAttemptTracer* StartNewAttempt(bool is_transparent_retry) = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CALL_TRACER_H

data/src/core/lib/channel/channel_stack.h

@@ -78,7 +78,7 @@ struct grpc_call_element_args {
   const void* server_transport_data;
   grpc_call_context_element* context;
   const grpc_slice& path;
-  gpr_cycle_counter start_time;
+  gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
   grpc_millis deadline;
   grpc_core::Arena* arena;
   grpc_core::CallCombiner* call_combiner;

data/src/core/lib/channel/context.h

@@ -32,6 +32,9 @@ typedef enum {
   /// Value is a \a census_context.
   GRPC_CONTEXT_TRACING,
 
+  /// Value is a CallTracer object.
+  GRPC_CONTEXT_CALL_TRACER,
+
   /// Reserved for traffic_class_context.
   GRPC_CONTEXT_TRAFFIC,
 

data/src/core/lib/channel/status_util.h

@@ -53,6 +53,10 @@ class StatusCodeSet {
     return status_code_mask_ & (1 << status);
   }
 
+  bool operator==(const StatusCodeSet& other) const {
+    return status_code_mask_ == other.status_code_mask_;
+  }
+
  private:
   int status_code_mask_ = 0;  // A bitfield of status codes in the set.
 };

data/src/core/lib/compression/stream_compression.h

@@ -113,4 +113,4 @@ void grpc_stream_compression_context_destroy(
 int grpc_stream_compression_method_parse(
     grpc_slice value, bool is_compress, grpc_stream_compression_method* method);
 
-#endif
+#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_H

data/src/core/lib/compression/stream_compression_gzip.h

@@ -25,4 +25,4 @@
 
 extern const grpc_stream_compression_vtable grpc_stream_compression_gzip_vtable;
 
-#endif
+#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_GZIP_H

data/src/core/lib/compression/stream_compression_identity.h

@@ -26,4 +26,4 @@
 extern const grpc_stream_compression_vtable
     grpc_stream_compression_identity_vtable;
 
-#endif
+#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_IDENTITY_H

data/src/core/lib/debug/stats.h

@@ -67,4 +67,4 @@ double grpc_stats_histo_percentile(const grpc_stats_data* stats,
 size_t grpc_stats_histo_count(const grpc_stats_data* stats,
                               grpc_stats_histograms histogram);
 
-#endif
+#endif  // GRPC_CORE_LIB_DEBUG_STATS_H

data/src/core/lib/gpr/murmur_hash.cc

@@ -22,6 +22,8 @@
 
 #include <string.h>
 
+#include "absl/base/attributes.h"
+
 #define ROTL32(x, r) (((x) << (r)) | ((x) >> (32 - (r))))
 
 #define FMIX32(h)    \
@@ -61,10 +63,10 @@ uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed) {
   switch (len & 3) {
     case 3:
       k1 ^= (static_cast<uint32_t>(keyptr[2])) << 16;
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 2:
       k1 ^= (static_cast<uint32_t>(keyptr[1])) << 8;
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 1:
       k1 ^= keyptr[0];
       k1 *= c1;