grpc 1.39.0 → 1.41.0

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

@@ -31,8 +31,8 @@ namespace grpc_core {
 
 namespace {
 
-uint64_t GetAndResetCounter(Atomic<uint64_t>* from) {
-  return from->Exchange(0, MemoryOrder::RELAXED);
+uint64_t GetAndResetCounter(std::atomic<uint64_t>* from) {
+  return from->exchange(0, std::memory_order_relaxed);
 }
 
 }  // namespace
@@ -82,7 +82,7 @@ XdsClusterDropStats::Snapshot XdsClusterDropStats::GetSnapshotAndReset() {
 }
 
 void XdsClusterDropStats::AddUncategorizedDrops() {
-  uncategorized_drops_.FetchAdd(1);
+  uncategorized_drops_.fetch_add(1);
 }
 
 void XdsClusterDropStats::AddCallDropped(const std::string& category) {
@@ -132,28 +132,29 @@ XdsClusterLocalityStats::~XdsClusterLocalityStats() {
 
 XdsClusterLocalityStats::Snapshot
 XdsClusterLocalityStats::GetSnapshotAndReset() {
-  Snapshot snapshot = {GetAndResetCounter(&total_successful_requests_),
-                       // Don't reset total_requests_in_progress because it's
-                       // not related to a single reporting interval.
-                       total_requests_in_progress_.Load(MemoryOrder::RELAXED),
-                       GetAndResetCounter(&total_error_requests_),
-                       GetAndResetCounter(&total_issued_requests_),
-                       {}};
+  Snapshot snapshot = {
+      GetAndResetCounter(&total_successful_requests_),
+      // Don't reset total_requests_in_progress because it's
+      // not related to a single reporting interval.
+      total_requests_in_progress_.load(std::memory_order_relaxed),
+      GetAndResetCounter(&total_error_requests_),
+      GetAndResetCounter(&total_issued_requests_),
+      {}};
   MutexLock lock(&backend_metrics_mu_);
   snapshot.backend_metrics = std::move(backend_metrics_);
   return snapshot;
 }
 
 void XdsClusterLocalityStats::AddCallStarted() {
-  total_issued_requests_.FetchAdd(1, MemoryOrder::RELAXED);
-  total_requests_in_progress_.FetchAdd(1, MemoryOrder::RELAXED);
+  total_issued_requests_.fetch_add(1, std::memory_order_relaxed);
+  total_requests_in_progress_.fetch_add(1, std::memory_order_relaxed);
 }
 
 void XdsClusterLocalityStats::AddCallFinished(bool fail) {
-  Atomic<uint64_t>& to_increment =
+  std::atomic<uint64_t>& to_increment =
       fail ? total_error_requests_ : total_successful_requests_;
-  to_increment.FetchAdd(1, MemoryOrder::RELAXED);
-  total_requests_in_progress_.FetchAdd(-1, MemoryOrder::ACQ_REL);
+  to_increment.fetch_add(1, std::memory_order_relaxed);
+  total_requests_in_progress_.fetch_add(-1, std::memory_order_acq_rel);
 }
 
 }  // namespace grpc_core

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <atomic>
 #include <map>
 #include <string>
 
@@ -29,7 +30,6 @@
 #include "absl/strings/string_view.h"
 
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -144,7 +144,7 @@ class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
   absl::string_view lrs_server_name_;
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
-  Atomic<uint64_t> uncategorized_drops_{0};
+  std::atomic<uint64_t> uncategorized_drops_{0};
   // Protects categorized_drops_. A mutex is necessary because the length of
   // dropped_requests can be accessed by both the picker (from data plane
   // mutex) and the load reporting thread (from the control plane combiner).
@@ -221,10 +221,10 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   absl::string_view eds_service_name_;
   RefCountedPtr<XdsLocalityName> name_;
 
-  Atomic<uint64_t> total_successful_requests_{0};
-  Atomic<uint64_t> total_requests_in_progress_{0};
-  Atomic<uint64_t> total_error_requests_{0};
-  Atomic<uint64_t> total_issued_requests_{0};
+  std::atomic<uint64_t> total_successful_requests_{0};
+  std::atomic<uint64_t> total_requests_in_progress_{0};
+  std::atomic<uint64_t> total_error_requests_{0};
+  std::atomic<uint64_t> total_issued_requests_{0};
 
   // Protects backend_metrics_. A mutex is necessary because the length of
   // backend_metrics_ can be accessed by both the callback intercepting the

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

@@ -18,8 +18,6 @@
 
 #include "src/core/ext/xds/xds_http_fault_filter.h"
 
-#include <grpc/grpc.h>
-
 #include <string>
 
 #include "absl/status/statusor.h"
@@ -33,6 +31,10 @@
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "upb/def.h"
+
+#include <grpc/grpc.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"
@@ -40,7 +42,6 @@
 #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 {
 

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

@@ -19,11 +19,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
+#include "upb/def.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 {
 

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

@@ -20,6 +20,7 @@
 
 #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 {
@@ -52,10 +53,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 +65,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/ext/xds/xds_server_config_fetcher.cc

@@ -259,12 +259,12 @@ FilterChainMatchManager::CreateOrGetXdsCertificateProviderFromFilterChainData(
   // Configure root cert.
   absl::string_view root_provider_instance_name =
       filter_chain->downstream_tls_context.common_tls_context
-          .combined_validation_context
-          .validation_context_certificate_provider_instance.instance_name;
+          .certificate_validation_context.ca_certificate_provider_instance
+          .instance_name;
   absl::string_view root_provider_cert_name =
       filter_chain->downstream_tls_context.common_tls_context
-          .combined_validation_context
-          .validation_context_certificate_provider_instance.certificate_name;
+          .certificate_validation_context.ca_certificate_provider_instance
+          .certificate_name;
   if (!root_provider_instance_name.empty()) {
     certificate_providers.root =
         xds_client_->certificate_provider_store()
@@ -278,10 +278,10 @@ FilterChainMatchManager::CreateOrGetXdsCertificateProviderFromFilterChainData(
   // Configure identity cert.
   absl::string_view identity_provider_instance_name =
       filter_chain->downstream_tls_context.common_tls_context
-          .tls_certificate_certificate_provider_instance.instance_name;
+          .tls_certificate_provider_instance.instance_name;
   absl::string_view identity_provider_cert_name =
       filter_chain->downstream_tls_context.common_tls_context
-          .tls_certificate_certificate_provider_instance.certificate_name;
+          .tls_certificate_provider_instance.certificate_name;
   if (!identity_provider_instance_name.empty()) {
     certificate_providers.instance =
         xds_client_->certificate_provider_store()
@@ -428,7 +428,7 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
         if (serving_status_notifier_.on_serving_status_update != nullptr) {
           serving_status_notifier_.on_serving_status_update(
               serving_status_notifier_.user_data, listening_address_.c_str(),
-              GRPC_STATUS_OK, "");
+              {GRPC_STATUS_OK, ""});
         } else {
           gpr_log(GPR_INFO,
                   "xDS Listener resource obtained; will start serving on %s",
@@ -459,7 +459,7 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
         if (serving_status_notifier_.on_serving_status_update != nullptr) {
           serving_status_notifier_.on_serving_status_update(
               serving_status_notifier_.user_data, listening_address_.c_str(),
-              GRPC_STATUS_UNAVAILABLE, grpc_error_std_string(error).c_str());
+              {GRPC_STATUS_UNAVAILABLE, grpc_error_std_string(error).c_str()});
         } else {
           gpr_log(
               GPR_ERROR,
@@ -486,8 +486,8 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
       if (serving_status_notifier_.on_serving_status_update != nullptr) {
         serving_status_notifier_.on_serving_status_update(
             serving_status_notifier_.user_data, listening_address_.c_str(),
-            static_cast<grpc_status_code>(status.raw_code()),
-            std::string(status.message()).c_str());
+            {static_cast<grpc_status_code>(status.raw_code()),
+             std::string(status.message()).c_str()});
       }
     }
 

data/src/core/lib/address_utils/parse_address.cc

@@ -87,10 +87,8 @@ grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
   if (path.size() > maxlen) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Path name should not have more than ", maxlen,
-                     " characters")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
   }
   un->sun_family = AF_UNIX;
   path.copy(un->sun_path, path.size());
@@ -105,10 +103,8 @@ grpc_error_handle UnixAbstractSockaddrPopulate(
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
   if (path.size() > maxlen) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Path name should not have more than ", maxlen,
-                     " characters")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
   }
   un->sun_family = AF_UNIX;
   un->sun_path[0] = '\0';

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -212,8 +212,8 @@ grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
     addr4->sin_family = GRPC_AF_INET;
     out->len = sizeof(grpc_sockaddr_in);
   } else {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Failed to parse address:", addr).c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("Failed to parse address:", addr));
   }
   grpc_sockaddr_set_port(out, port);
   return GRPC_ERROR_NONE;

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_args.cc

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/channel_args.h"
+
 #include <limits.h>
 #include <string.h>
 
@@ -33,7 +35,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 

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

@@ -18,14 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gpr/alloc.h"
 
 #include <stdlib.h>
 #include <string.h>
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gpr/alloc.h"
+
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
 
 /* Memory layouts.

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/channel_stack_builder.cc

@@ -41,6 +41,7 @@ struct grpc_channel_stack_builder {
   grpc_channel_args* args;
   grpc_transport* transport;
   grpc_resource_user* resource_user;
+  size_t preallocated_bytes;
   char* target;
   const char* name;
 };
@@ -174,17 +175,6 @@ grpc_transport* grpc_channel_stack_builder_get_transport(
   return builder->transport;
 }
 
-void grpc_channel_stack_builder_set_resource_user(
-    grpc_channel_stack_builder* builder, grpc_resource_user* resource_user) {
-  GPR_ASSERT(builder->resource_user == nullptr);
-  builder->resource_user = resource_user;
-}
-
-grpc_resource_user* grpc_channel_stack_builder_get_resource_user(
-    grpc_channel_stack_builder* builder) {
-  return builder->resource_user;
-}
-
 bool grpc_channel_stack_builder_append_filter(
     grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
     grpc_post_filter_create_init_func post_init_func, void* user_data) {

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

@@ -54,14 +54,6 @@ void grpc_channel_stack_builder_set_transport(
 grpc_transport* grpc_channel_stack_builder_get_transport(
     grpc_channel_stack_builder* builder);
 
-/// Attach \a resource_user to the builder (does not take ownership)
-void grpc_channel_stack_builder_set_resource_user(
-    grpc_channel_stack_builder* builder, grpc_resource_user* resource_user);
-
-/// Fetch attached resource user
-grpc_resource_user* grpc_channel_stack_builder_get_resource_user(
-    grpc_channel_stack_builder* builder);
-
 /// Set channel arguments: copies args
 void grpc_channel_stack_builder_set_channel_arguments(
     grpc_channel_stack_builder* builder, const grpc_channel_args* args);

data/src/core/lib/channel/channel_trace.cc

@@ -20,13 +20,14 @@
 
 #include "src/core/lib/channel/channel_trace.h"
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"

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

@@ -22,6 +22,7 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #include <grpc/grpc.h>
+
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/error.h"