grpc 1.44.0.pre2 → 1.45.0

data/src/core/lib/transport/metadata_batch.h

@@ -23,8 +23,10 @@
 
 #include <stdbool.h>
 
+#include <cstdint>
 #include <limits>
 
+#include "absl/strings/escaping.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_join.h"
 #include "absl/types/optional.h"
@@ -46,7 +48,7 @@
 namespace grpc_core {
 
 // grpc-timeout metadata trait.
-// ValueType is defined as grpc_millis - an absolute timestamp (i.e. a
+// ValueType is defined as Timestamp - an absolute timestamp (i.e. a
 // deadline!), that is converted to a duration by transports before being
 // sent.
 // TODO(ctiller): Move this elsewhere. During the transition we need to be able
@@ -54,27 +56,27 @@ namespace grpc_core {
 // should not need to.
 struct GrpcTimeoutMetadata {
   static constexpr bool kRepeatable = false;
-  using ValueType = grpc_millis;
-  using MementoType = grpc_millis;
+  using ValueType = Timestamp;
+  using MementoType = Duration;
   static absl::string_view key() { return "grpc-timeout"; }
   static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error) {
     auto timeout = ParseTimeout(value);
     if (!timeout.has_value()) {
       on_error("invalid value", value);
-      return GRPC_MILLIS_INF_FUTURE;
+      return Duration::Infinity();
     }
     return *timeout;
   }
   static ValueType MementoToValue(MementoType timeout) {
-    if (timeout == GRPC_MILLIS_INF_FUTURE) {
-      return GRPC_MILLIS_INF_FUTURE;
+    if (timeout == Duration::Infinity()) {
+      return Timestamp::InfFuture();
     }
     return ExecCtx::Get()->Now() + timeout;
   }
   static Slice Encode(ValueType x) {
     return Timeout::FromDuration(x - ExecCtx::Get()->Now()).Encode();
   }
-  static MementoType DisplayValue(MementoType x) { return x; }
+  static std::string DisplayValue(MementoType x) { return x.ToString(); }
 };
 
 // TE metadata trait.
@@ -152,7 +154,7 @@ struct ContentTypeMetadata {
       case kApplicationGrpc:
         return StaticSlice::FromStaticString("application/grpc");
       case kInvalid:
-        abort();
+        return StaticSlice::FromStaticString("application/grpc+unknown");
     }
     GPR_UNREACHABLE_CODE(
         return StaticSlice::FromStaticString("unrepresentable value"));
@@ -431,10 +433,22 @@ struct GrpcPreviousRpcAttemptsMetadata
 };
 
 // grpc-retry-pushback-ms metadata trait.
-struct GrpcRetryPushbackMsMetadata
-    : public SimpleIntBasedMetadata<grpc_millis, GRPC_MILLIS_INF_PAST> {
+struct GrpcRetryPushbackMsMetadata {
   static constexpr bool kRepeatable = false;
   static absl::string_view key() { return "grpc-retry-pushback-ms"; }
+  using ValueType = Duration;
+  using MementoType = Duration;
+  static ValueType MementoToValue(MementoType x) { return x; }
+  static Slice Encode(Duration x) { return Slice::FromInt64(x.millis()); }
+  static int64_t DisplayValue(Duration x) { return x.millis(); }
+  static Duration ParseMemento(Slice value, MetadataParseErrorFn on_error) {
+    int64_t out;
+    if (!absl::SimpleAtoi(value.as_string_view(), &out)) {
+      on_error("not an integer", value);
+      return Duration::NegativeInfinity();
+    }
+    return Duration::Milliseconds(out);
+  }
 };
 
 // :status metadata trait.
@@ -500,14 +514,57 @@ struct LbCostBinMetadata {
   }
 };
 
+// Annotation added by a transport to note whether a failed request was never
+// placed on the wire, or never seen by a server.
+struct GrpcStreamNetworkState {
+  static absl::string_view DebugKey() { return "GrpcStreamNetworkState"; }
+  static constexpr bool kRepeatable = false;
+  enum ValueType : uint8_t {
+    kNotSentOnWire,
+    kNotSeenByServer,
+  };
+  static std::string DisplayValue(ValueType x) {
+    switch (x) {
+      case kNotSentOnWire:
+        return "not sent on wire";
+      case kNotSeenByServer:
+        return "not seen by server";
+    }
+  }
+};
+
+// Annotation added by various systems to describe the reason for a failure.
+struct GrpcStatusContext {
+  static absl::string_view DebugKey() { return "GrpcStatusContext"; }
+  static constexpr bool kRepeatable = true;
+  using ValueType = std::string;
+  static const std::string& DisplayValue(const std::string& x) { return x; }
+};
+
 namespace metadata_detail {
 
+// IsEncodable: Given a trait, determine if that trait is encodable, or is just
+// a value attached to a MetadataMap.
+// We use the presence of the key() static method to determine if a trait is
+// encodable or not - encodable traits have string names, and non-encodable
+// traits do not.
+template <typename Trait, typename Ignored = void>
+struct IsEncodableTrait {
+  static const bool value = false;
+};
+
+template <typename Trait>
+struct IsEncodableTrait<Trait, absl::void_t<decltype(Trait::key())>> {
+  static const bool value = true;
+};
+
 // Helper type - maps a string name to a trait.
-template <typename... Traits>
+template <typename MustBeVoid, typename... Traits>
 struct NameLookup;
 
 template <typename Trait, typename... Traits>
-struct NameLookup<Trait, Traits...> {
+struct NameLookup<absl::enable_if_t<IsEncodableTrait<Trait>::value, void>,
+                  Trait, Traits...> {
   // Call op->Found(Trait()) if op->name == Trait::key() for some Trait in
   // Traits. If not found, call op->NotFound().
   template <typename Op>
@@ -516,12 +573,22 @@ struct NameLookup<Trait, Traits...> {
     if (key == Trait::key()) {
       return op->Found(Trait());
     }
-    return NameLookup<Traits...>::Lookup(key, op);
+    return NameLookup<void, Traits...>::Lookup(key, op);
+  }
+};
+
+template <typename Trait, typename... Traits>
+struct NameLookup<absl::enable_if_t<!IsEncodableTrait<Trait>::value, void>,
+                  Trait, Traits...> {
+  template <typename Op>
+  static auto Lookup(absl::string_view key, Op* op)
+      -> decltype(NameLookup<void, Traits...>::Lookup(key, op)) {
+    return NameLookup<void, Traits...>::Lookup(key, op);
   }
 };
 
 template <>
-struct NameLookup<> {
+struct NameLookup<void> {
   template <typename Op>
   static auto Lookup(absl::string_view key, Op* op)
       -> decltype(op->NotFound(key)) {
@@ -688,12 +755,42 @@ class GetStringValueHelper {
   std::string* backing_;
 };
 
+// Sink for key value logs
+using LogFn = absl::FunctionRef<void(absl::string_view, absl::string_view)>;
+
+template <typename T>
+struct AdaptDisplayValueToLog {
+  static std::string ToString(const T& value) { return absl::StrCat(value); }
+};
+
+template <>
+struct AdaptDisplayValueToLog<Slice> {
+  static std::string ToString(Slice value) {
+    return std::string(value.as_string_view());
+  }
+};
+
+template <>
+struct AdaptDisplayValueToLog<StaticSlice> {
+  static absl::string_view ToString(StaticSlice value) {
+    return value.as_string_view();
+  }
+};
+
+template <typename T, typename U, typename V>
+GPR_ATTRIBUTE_NOINLINE void LogKeyValueTo(absl::string_view key, const T& value,
+                                          V (*display_value)(U), LogFn log_fn) {
+  log_fn(key, AdaptDisplayValueToLog<V>::ToString(display_value(value)));
+}
+
 // Generate a strong type for metadata values per trait.
 template <typename Which, typename Ignored = void>
 struct Value;
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == false, void>> {
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
+                                          IsEncodableTrait<Which>::value,
+                                      void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) : value(value) {}
   explicit Value(typename Which::ValueType&& value)
@@ -709,12 +806,41 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false, void>> {
   void EncodeTo(Encoder* encoder) const {
     encoder->Encode(Which(), value);
   }
+  void LogTo(LogFn log_fn) const {
+    LogKeyValueTo(Which::key(), value, Which::Encode, log_fn);
+  }
   using StorageType = typename Which::ValueType;
   GPR_NO_UNIQUE_ADDRESS StorageType value;
 };
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == true, void>> {
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
+                                          !IsEncodableTrait<Which>::value,
+                                      void>> {
+  Value() = default;
+  explicit Value(const typename Which::ValueType& value) : value(value) {}
+  explicit Value(typename Which::ValueType&& value)
+      : value(std::forward<typename Which::ValueType>(value)) {}
+  Value(const Value&) = delete;
+  Value& operator=(const Value&) = delete;
+  Value(Value&&) noexcept = default;
+  Value& operator=(Value&& other) noexcept {
+    value = std::move(other.value);
+    return *this;
+  }
+  template <typename Encoder>
+  void EncodeTo(Encoder*) const {}
+  void LogTo(LogFn log_fn) const {
+    LogKeyValueTo(Which::DebugKey(), value, Which::DisplayValue, log_fn);
+  }
+  using StorageType = typename Which::ValueType;
+  GPR_NO_UNIQUE_ADDRESS StorageType value;
+};
+
+template <typename Which>
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
+                                          IsEncodableTrait<Which>::value,
+                                      void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) {
     this->value.push_back(value);
@@ -735,6 +861,40 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == true, void>> {
       encoder->Encode(Which(), v);
     }
   }
+  void LogTo(LogFn log_fn) const {
+    for (const auto& v : value) {
+      LogKeyValueTo(Which::key(), v, Which::Encode, log_fn);
+    }
+  }
+  using StorageType = absl::InlinedVector<typename Which::ValueType, 1>;
+  StorageType value;
+};
+
+template <typename Which>
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
+                                          !IsEncodableTrait<Which>::value,
+                                      void>> {
+  Value() = default;
+  explicit Value(const typename Which::ValueType& value) {
+    this->value.push_back(value);
+  }
+  explicit Value(typename Which::ValueType&& value) {
+    this->value.emplace_back(std::forward<typename Which::ValueType>(value));
+  }
+  Value(const Value&) = delete;
+  Value& operator=(const Value&) = delete;
+  Value(Value&& other) noexcept : value(std::move(other.value)) {}
+  Value& operator=(Value&& other) noexcept {
+    value = std::move(other.value);
+    return *this;
+  }
+  template <typename Encoder>
+  void EncodeTo(Encoder*) const {}
+  void LogTo(LogFn log_fn) const {
+    for (const auto& v : value) {
+      LogKeyValueTo(Which::DebugKey(), v, Which::DisplayValue, log_fn);
+    }
+  }
   using StorageType = absl::InlinedVector<typename Which::ValueType, 1>;
   StorageType value;
 };
@@ -763,6 +923,55 @@ class CopySink {
   Output* dst_;
 };
 
+// Callable for the ForEach in Encode() -- for each value, call the
+// appropriate encoder method.
+template <typename Encoder>
+struct EncodeWrapper {
+  Encoder* encoder;
+  template <typename Which>
+  void operator()(const Value<Which>& which) {
+    which.EncodeTo(encoder);
+  }
+};
+
+// Callable for the ForEach in Log()
+struct LogWrapper {
+  LogFn log_fn;
+  template <typename Which>
+  void operator()(const Value<Which>& which) {
+    which.LogTo(log_fn);
+  }
+};
+
+// Encoder to compute TransportSize
+class TransportSizeEncoder {
+ public:
+  void Encode(const Slice& key, const Slice& value) {
+    size_ += key.length() + value.length() + 32;
+  }
+
+  template <typename Which>
+  void Encode(Which, const typename Which::ValueType& value) {
+    Add(Which(), value);
+  }
+
+  void Encode(ContentTypeMetadata,
+              const typename ContentTypeMetadata::ValueType& value) {
+    if (value == ContentTypeMetadata::kInvalid) return;
+    Add(ContentTypeMetadata(), value);
+  }
+
+  size_t size() const { return size_; }
+
+ private:
+  template <typename Which>
+  void Add(Which, const typename Which::ValueType& value) {
+    size_ += Which::key().length() + Which::Encode(value).length() + 32;
+  }
+
+  uint32_t size_ = 0;
+};
+
 }  // namespace metadata_detail
 
 // Helper function for encoders
@@ -804,13 +1013,18 @@ MetadataValueAsSlice(typename Which::ValueType value) {
 // of the number of traits, and so we return to a linear symbol table growth
 // function.
 //
-// Each trait object has the following signature:
-// // Traits for the grpc-xyz metadata field:
+// Each trait object has one of two possible signatures, depending on whether
+// that traits field is encodable or not.
+// Non-encodable traits are carried in a MetadataMap, but are never passed to
+// the application nor serialized to wire.
+//
+// Encodable traits have the following signature:
+// // Traits for the "grpc-xyz" metadata field:
 // struct GrpcXyzMetadata {
-//   // The type that's stored on MetadataBatch
-//   using ValueType = ...;
 //   // Can this metadata field be repeated?
 //   static constexpr bool kRepeatable = ...;
+//   // The type that's stored on MetadataBatch
+//   using ValueType = ...;
 //   // The type that's stored in compression/decompression tables
 //   using MementoType = ...;
 //   // The string key for this metadata type (for transports that require it)
@@ -830,6 +1044,23 @@ MetadataValueAsSlice(typename Which::ValueType value) {
 //   static SomeStrCatableType DisplayValue(MementoType value) { ... }
 // };
 //
+// Non-encodable traits are determined by missing the key() method, and have the
+// following signature (and by convention omit the Metadata part of the type
+// name):
+// // Traits for the GrpcXyz field:
+// struct GrpcXyz {
+//   // The string key that should be used for debug dumps - should not be a
+//   // valid http2 key (ie all lower case)
+//   static absl::string_view DebugKey() { return "GRPC_XYZ"; }
+//   // Can this metadata field be repeated?
+//   static constexpr bool kRepeatable = ...;
+//   // The type that's stored on MetadataBatch
+//   using ValueType = ...;
+//   // Convert a value to something that can be passed to StrCat and displayed
+//   // for debugging
+//   static SomeStrCatableType DisplayValue(ValueType value) { ... }
+// };
+//
 // About parsing and mementos:
 //
 // Many gRPC transports exchange metadata as key/value strings, but also allow
@@ -878,7 +1109,7 @@ class MetadataMap {
   // transitions.
   template <typename Encoder>
   void Encode(Encoder* encoder) const {
-    table_.ForEach(EncodeWrapper<Encoder>{encoder});
+    table_.ForEach(metadata_detail::EncodeWrapper<Encoder>{encoder});
     for (const auto& unk : unknown_) {
       encoder->Encode(unk.first, unk.second);
     }
@@ -886,8 +1117,21 @@ class MetadataMap {
 
   // Similar to Encode, but targeted at logging: for each metadatum,
   // call f(key, value) as absl::string_views.
-  void Log(absl::FunctionRef<void(absl::string_view, absl::string_view)> log_fn)
-      const;
+  void Log(metadata_detail::LogFn log_fn) const {
+    table_.ForEach(metadata_detail::LogWrapper{log_fn});
+    for (const auto& unk : unknown_) {
+      log_fn(unk.first.as_string_view(), unk.second.as_string_view());
+    }
+  }
+
+  std::string DebugString() const {
+    std::string out;
+    Log([&out](absl::string_view key, absl::string_view value) {
+      if (!out.empty()) out.append(", ");
+      absl::StrAppend(&out, absl::CEscape(key), ": ", absl::CEscape(value));
+    });
+    return out;
+  }
 
   // Get the pointer to the value of some known metadata.
   // Returns nullptr if the metadata is not present.
@@ -948,7 +1192,7 @@ class MetadataMap {
   // Remove some metadata by name
   void Remove(absl::string_view key) {
     metadata_detail::RemoveHelper<Derived> helper(static_cast<Derived*>(this));
-    metadata_detail::NameLookup<Traits...>::Lookup(key, &helper);
+    metadata_detail::NameLookup<void, Traits...>::Lookup(key, &helper);
   }
 
   void Remove(const char* key) { Remove(absl::string_view(key)); }
@@ -958,7 +1202,7 @@ class MetadataMap {
                                                    std::string* buffer) const {
     metadata_detail::GetStringValueHelper<Derived> helper(
         static_cast<const Derived*>(this), buffer);
-    return metadata_detail::NameLookup<Traits...>::Lookup(name, &helper);
+    return metadata_detail::NameLookup<void, Traits...>::Lookup(name, &helper);
   }
 
   // Extract a piece of known metadata.
@@ -1001,7 +1245,7 @@ class MetadataMap {
                                        MetadataParseErrorFn on_error) {
     metadata_detail::ParseHelper<Derived> helper(value.TakeOwned(), on_error,
                                                  transport_size);
-    return metadata_detail::NameLookup<Traits...>::Lookup(key, &helper);
+    return metadata_detail::NameLookup<void, Traits...>::Lookup(key, &helper);
   }
 
   // Set a value from a parsed metadata object.
@@ -1014,7 +1258,7 @@ class MetadataMap {
               MetadataParseErrorFn on_error) {
     metadata_detail::AppendHelper<Derived> helper(static_cast<Derived*>(this),
                                                   value.TakeOwned(), on_error);
-    metadata_detail::NameLookup<Traits...>::Lookup(key, &helper);
+    metadata_detail::NameLookup<void, Traits...>::Lookup(key, &helper);
   }
 
   void Clear();
@@ -1033,66 +1277,6 @@ class MetadataMap {
   template <typename Which>
   using Value = metadata_detail::Value<Which>;
 
-  // Callable for the ForEach in Encode() -- for each value, call the
-  // appropriate encoder method.
-  template <typename Encoder>
-  struct EncodeWrapper {
-    Encoder* encoder;
-    template <typename Which>
-    void operator()(const Value<Which>& which) {
-      which.EncodeTo(encoder);
-    }
-  };
-
-  // Encoder to compute TransportSize
-  class TransportSizeEncoder {
-   public:
-    void Encode(const Slice& key, const Slice& value) {
-      size_ += key.length() + value.length() + 32;
-    }
-
-    template <typename Which>
-    void Encode(Which, const typename Which::ValueType& value) {
-      Add(Which(), value);
-    }
-
-    void Encode(ContentTypeMetadata,
-                const typename ContentTypeMetadata::ValueType& value) {
-      if (value == ContentTypeMetadata::kInvalid) return;
-      Add(ContentTypeMetadata(), value);
-    }
-
-    size_t size() const { return size_; }
-
-   private:
-    template <typename Which>
-    void Add(Which, const typename Which::ValueType& value) {
-      size_ += Which::key().length() + Which::Encode(value).length() + 32;
-    }
-
-    uint32_t size_ = 0;
-  };
-
-  // Encoder to log some metadata
-  class LogEncoder {
-   public:
-    explicit LogEncoder(
-        absl::FunctionRef<void(absl::string_view, absl::string_view)> log_fn)
-        : log_fn_(log_fn) {}
-
-    template <typename Which>
-    void Encode(Which, const typename Which::ValueType& value) {
-      log_fn_(Which::key(), absl::StrCat(Which::DisplayValue(value)));
-    }
-
-    void Encode(const Slice& key, const Slice& value) {
-      log_fn_(key.as_string_view(), value.as_string_view());
-    }
-
-   private:
-    absl::FunctionRef<void(absl::string_view, absl::string_view)> log_fn_;
-  };
-
   void AppendUnknown(absl::string_view key, Slice value) {
     unknown_.EmplaceBack(Slice::FromCopiedString(key), value.Ref());
   }
@@ -1162,7 +1346,7 @@ void MetadataMap<Derived, Traits...>::Clear() {
 
 template <typename Derived, typename... Traits>
 size_t MetadataMap<Derived, Traits...>::TransportSize() const {
-  TransportSizeEncoder enc;
+  metadata_detail::TransportSizeEncoder enc;
   Encode(&enc);
   return enc.size();
 }
@@ -1175,14 +1359,6 @@ Derived MetadataMap<Derived, Traits...>::Copy() const {
   return out;
 }
 
-template <typename Derived, typename... Traits>
-void MetadataMap<Derived, Traits...>::Log(
-    absl::FunctionRef<void(absl::string_view, absl::string_view)> log_fn)
-    const {
-  LogEncoder enc(log_fn);
-  Encode(&enc);
-}
-
 }  // namespace grpc_core
 
 struct grpc_metadata_batch;
@@ -1203,7 +1379,9 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::XEndpointLoadMetricsBinMetadata,
     grpc_core::GrpcServerStatsBinMetadata, grpc_core::GrpcTraceBinMetadata,
     grpc_core::GrpcTagsBinMetadata, grpc_core::GrpcLbClientStatsMetadata,
-    grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata>;
+    grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
+    // Non-encodable things
+    grpc_core::GrpcStreamNetworkState, grpc_core::GrpcStatusContext>;
 
 struct grpc_metadata_batch : public grpc_metadata_batch_base {
   using grpc_metadata_batch_base::grpc_metadata_batch_base;