grpc 1.44.0.pre2 → 1.45.0

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

@@ -23,6 +23,7 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/match.h"
 
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/validate_metadata.h"
@@ -39,13 +40,14 @@ namespace metadata_detail {
 template <typename Which>
 struct HasSimpleMemento {
   static constexpr bool value =
-      std::is_trivial<typename Which::MementoType>::value &&
-      sizeof(typename Which::MementoType) <= sizeof(grpc_slice);
+      (std::is_trivial<typename Which::MementoType>::value &&
+       sizeof(typename Which::MementoType) <= sizeof(grpc_slice)) ||
+      std::is_same<typename Which::MementoType, Duration>::value;
 };
 
 // Storage type for a single metadata entry.
 union Buffer {
-  char trivial[sizeof(grpc_slice)];
+  uint8_t trivial[sizeof(grpc_slice)];
   void* pointer;
   grpc_slice slice;
 };
@@ -72,9 +74,9 @@ GPR_ATTRIBUTE_NOINLINE std::string MakeDebugStringPipeline(
 // Extract a trivial field value from a Buffer - for MakeDebugStringPipeline.
 template <typename Field>
 Field FieldFromTrivial(const Buffer& value) {
-  Field x;
-  memcpy(&x, value.trivial, sizeof(x));
-  return x;
+  Field field;
+  memcpy(&field, value.trivial, sizeof(Field));
+  return field;
 }
 
 // Extract a pointer field value from a Buffer - for MakeDebugStringPipeline.
@@ -92,6 +94,12 @@ void DestroySliceValue(const Buffer& value);
 // Destroy a trivial memento (empty function).
 void DestroyTrivialMemento(const Buffer& value);
 
+// Set a slice value in a container
+template <Slice (*MementoToValue)(Slice)>
+void SetSliceValue(Slice* set, const Buffer& value) {
+  *set = MementoToValue(SliceFromBuffer(value));
+}
+
 }  // namespace metadata_detail
 
 // A parsed metadata value.
@@ -177,13 +185,15 @@ class ParsedMetadata {
     ParsedMetadata result;
     result.vtable_ = vtable_;
     result.value_ = value_;
-    result.transport_size_ =
-        TransportSize(vtable_->key(value_).length(), value.length());
+    result.transport_size_ = TransportSize(key().length(), value.length());
     vtable_->with_new_value(&value, on_error, &result);
     return result;
   }
   std::string DebugString() const { return vtable_->debug_string(value_); }
-  absl::string_view key() const { return vtable_->key(value_); }
+  absl::string_view key() const {
+    if (vtable_->key == nullptr) return vtable_->key_value;
+    return vtable_->key(value_);
+  }
 
   // TODO(ctiller): move to transport
   static uint32_t TransportSize(uint32_t key_size, uint32_t value_size) {
@@ -203,6 +213,8 @@ class ParsedMetadata {
                                  MetadataParseErrorFn on_error,
                                  ParsedMetadata* result);
     std::string (*const debug_string)(const Buffer& value);
+    // The key - if key is null, use key_value, otherwise call key.
+    absl::string_view key_value;
     absl::string_view (*const key)(const Buffer& value);
   };
 
@@ -250,7 +262,8 @@ ParsedMetadata<MetadataContainer>::EmptyVTable() {
       // debug_string
       [](const Buffer&) -> std::string { return "empty"; },
       // key
-      [](const Buffer&) -> absl::string_view { return ""; },
+      "",
+      nullptr,
   };
   return &vtable;
 }
@@ -281,7 +294,8 @@ ParsedMetadata<MetadataContainer>::TrivialTraitVTable() {
             Which::DisplayValue);
       },
       // key
-      [](const Buffer&) { return Which::key(); },
+      Which::key(),
+      nullptr,
   };
   return &vtable;
 }
@@ -314,7 +328,8 @@ ParsedMetadata<MetadataContainer>::NonTrivialTraitVTable() {
             Which::DisplayValue);
       },
       // key
-      [](const Buffer&) { return Which::key(); },
+      Which::key(),
+      nullptr,
   };
   return &vtable;
 }
@@ -329,8 +344,8 @@ ParsedMetadata<MetadataContainer>::SliceTraitVTable() {
       metadata_detail::DestroySliceValue,
       // set
       [](const Buffer& value, MetadataContainer* map) {
-        map->Set(Which(), Which::MementoToValue(
-                              metadata_detail::SliceFromBuffer(value)));
+        metadata_detail::SetSliceValue<Which::MementoToValue>(
+            map->GetOrCreatePointer(Which()), value);
       },
       // with_new_value
       WithNewValueSetSlice<Which::ParseMemento>,
@@ -341,7 +356,8 @@ ParsedMetadata<MetadataContainer>::SliceTraitVTable() {
             Which::DisplayValue);
       },
       // key
-      [](const Buffer&) { return Which::key(); },
+      Which::key(),
+      nullptr,
   };
   return &vtable;
 }
@@ -374,8 +390,8 @@ ParsedMetadata<MetadataContainer>::KeyValueVTable(absl::string_view key) {
     return static_cast<KV*>(value.pointer)->first.as_string_view();
   };
   static const VTable vtable[2] = {
-      {false, destroy, set, with_new_value, debug_string, key_fn},
-      {true, destroy, set, with_new_value, debug_string, key_fn},
+      {false, destroy, set, with_new_value, debug_string, "", key_fn},
+      {true, destroy, set, with_new_value, debug_string, "", key_fn},
   };
   return &vtable[absl::EndsWith(key, "-bin")];
 }

data/src/core/lib/transport/status_conversion.cc

@@ -39,8 +39,8 @@ grpc_http2_error_code grpc_status_to_http2_error(grpc_status_code status) {
   }
 }
 
-grpc_status_code grpc_http2_error_to_grpc_status(grpc_http2_error_code error,
-                                                 grpc_millis deadline) {
+grpc_status_code grpc_http2_error_to_grpc_status(
+    grpc_http2_error_code error, grpc_core::Timestamp deadline) {
   switch (error) {
     case GRPC_HTTP2_NO_ERROR:
       /* should never be received */

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

@@ -29,7 +29,7 @@
 /* Conversion of grpc status codes to http2 error codes (for RST_STREAM) */
 grpc_http2_error_code grpc_status_to_http2_error(grpc_status_code status);
 grpc_status_code grpc_http2_error_to_grpc_status(grpc_http2_error_code error,
-                                                 grpc_millis deadline);
+                                                 grpc_core::Timestamp deadline);
 
 /* Conversion of HTTP status codes (:status) to grpc status codes */
 grpc_status_code grpc_http2_status_to_grpc_status(int status);

data/src/core/lib/transport/timeout_encoding.cc

@@ -23,6 +23,8 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <cstdint>
+
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/string.h"
@@ -37,7 +39,6 @@ int64_t DivideRoundingUp(int64_t dividend, int64_t divisor) {
 
 constexpr int64_t kSecondsPerMinute = 60;
 constexpr int64_t kMinutesPerHour = 60;
-constexpr int64_t kSecondsPerHour = kSecondsPerMinute * kMinutesPerHour;
 constexpr int64_t kMaxHours = 27000;
 
 bool IsAllSpace(const uint8_t* p, const uint8_t* end) {
@@ -47,13 +48,13 @@ bool IsAllSpace(const uint8_t* p, const uint8_t* end) {
 
 }  // namespace
 
-Timeout Timeout::FromDuration(grpc_millis duration) {
-  return Timeout::FromMillis(duration);
+Timeout Timeout::FromDuration(Duration duration) {
+  return Timeout::FromMillis(duration.millis());
 }
 
 double Timeout::RatioVersus(Timeout other) const {
-  double a = AsDuration();
-  double b = other.AsDuration();
+  double a = AsDuration().millis();
+  double b = other.AsDuration().millis();
   if (b == 0) {
     if (a > 0) return 100;
     if (a < 0) return -100;
@@ -62,33 +63,33 @@ double Timeout::RatioVersus(Timeout other) const {
   return 100 * (a / b - 1);
 }
 
-grpc_millis Timeout::AsDuration() const {
-  grpc_millis value = value_;
+Duration Timeout::AsDuration() const {
+  int64_t value = value_;
   switch (unit_) {
     case Unit::kNanoseconds:
-      return 0;
+      return Duration::Zero();
     case Unit::kMilliseconds:
-      return value;
+      return Duration::Milliseconds(value);
     case Unit::kTenMilliseconds:
-      return value * 10;
+      return Duration::Milliseconds(value * 10);
     case Unit::kHundredMilliseconds:
-      return value * 100;
+      return Duration::Milliseconds(value * 100);
     case Unit::kSeconds:
-      return value * 1000;
+      return Duration::Seconds(value);
     case Unit::kTenSeconds:
-      return value * 10000;
+      return Duration::Seconds(value * 10);
     case Unit::kHundredSeconds:
-      return value * 100000;
+      return Duration::Seconds(value * 100);
     case Unit::kMinutes:
-      return value * 1000 * kSecondsPerMinute;
+      return Duration::Minutes(value);
     case Unit::kTenMinutes:
-      return value * 10000 * kSecondsPerMinute;
+      return Duration::Minutes(value * 10);
     case Unit::kHundredMinutes:
-      return value * 100000 * kSecondsPerMinute;
+      return Duration::Minutes(value * 100);
     case Unit::kHours:
-      return value * 1000 * kSecondsPerHour;
+      return Duration::Hours(value);
   }
-  GPR_UNREACHABLE_CODE(return -1);
+  GPR_UNREACHABLE_CODE(return Duration::NegativeInfinity());
 }
 
 Slice Timeout::Encode() const {
@@ -228,8 +229,8 @@ Timeout Timeout::FromHours(int64_t hours) {
   return Timeout(kMaxHours, Unit::kHours);
 }
 
-absl::optional<grpc_millis> ParseTimeout(const Slice& text) {
-  grpc_millis x = 0;
+absl::optional<Duration> ParseTimeout(const Slice& text) {
+  int32_t x = 0;
   const uint8_t* p = text.begin();
   const uint8_t* end = text.end();
   int have_digit = 0;
@@ -243,7 +244,7 @@ absl::optional<grpc_millis> ParseTimeout(const Slice& text) {
     /* spec allows max. 8 digits, but we allow values up to 1,000,000,000 */
     if (x >= (100 * 1000 * 1000)) {
       if (x != (100 * 1000 * 1000) || digit != 0) {
-        return GRPC_MILLIS_INF_FUTURE;
+        return Duration::Infinity();
       }
     }
     x = x * 10 + digit;
@@ -254,25 +255,27 @@ absl::optional<grpc_millis> ParseTimeout(const Slice& text) {
   }
   if (p == end) return absl::nullopt;
   /* decode unit specifier */
-  int64_t timeout;
+  Duration timeout;
   switch (*p) {
     case 'n':
-      timeout = x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0);
+      timeout =
+          Duration::Milliseconds(x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0));
       break;
     case 'u':
-      timeout = x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0);
+      timeout =
+          Duration::Milliseconds(x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0));
       break;
     case 'm':
-      timeout = x;
+      timeout = Duration::Milliseconds(x);
       break;
     case 'S':
-      timeout = x * GPR_MS_PER_SEC;
+      timeout = Duration::Seconds(x);
       break;
     case 'M':
-      timeout = x * 60 * GPR_MS_PER_SEC;
+      timeout = Duration::Minutes(x);
       break;
     case 'H':
-      timeout = x * 60 * 60 * GPR_MS_PER_SEC;
+      timeout = Duration::Hours(x);
       break;
     default:
       return absl::nullopt;

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

@@ -28,12 +28,12 @@ namespace grpc_core {
 
 class Timeout {
  public:
-  static Timeout FromDuration(grpc_millis duration);
+  static Timeout FromDuration(Duration duration);
 
   // Computes: 100 * ((this - other) / other)
   double RatioVersus(Timeout other) const;
   Slice Encode() const;
-  grpc_millis AsDuration() const;
+  Duration AsDuration() const;
 
  private:
   enum class Unit : uint8_t {
@@ -61,7 +61,7 @@ class Timeout {
   Unit unit_;
 };
 
-absl::optional<grpc_millis> ParseTimeout(const Slice& text);
+absl::optional<Duration> ParseTimeout(const Slice& text);
 
 }  // namespace grpc_core
 

data/src/core/lib/transport/transport.cc

@@ -224,7 +224,9 @@ static void destroy_made_transport_stream_op(void* arg,
   made_transport_stream_op* op = static_cast<made_transport_stream_op*>(arg);
   grpc_closure* c = op->inner_on_complete;
   delete op;
-  grpc_core::Closure::Run(DEBUG_LOCATION, c, GRPC_ERROR_REF(error));
+  if (c != nullptr) {
+    grpc_core::Closure::Run(DEBUG_LOCATION, c, GRPC_ERROR_REF(error));
+  }
 }
 
 grpc_transport_stream_op_batch* grpc_make_transport_stream_op(

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

@@ -30,6 +30,7 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/byte_stream.h"
@@ -42,6 +43,79 @@
 #define GRPC_PROTOCOL_VERSION_MIN_MAJOR 2
 #define GRPC_PROTOCOL_VERSION_MIN_MINOR 1
 
+namespace grpc_core {
+// TODO(ctiller): eliminate once MetadataHandle is constructable directly.
+namespace promise_filter_detail {
+class BaseCallData;
+}
+
+// Small unowned "handle" type to ensure one accessor at a time to metadata.
+// The focus here is to get promises to use the syntax we'd like - we'll
+// probably substitute some other smart pointer later.
+template <typename T>
+class MetadataHandle {
+ public:
+  MetadataHandle() = default;
+
+  MetadataHandle(const MetadataHandle&) = delete;
+  MetadataHandle& operator=(const MetadataHandle&) = delete;
+
+  MetadataHandle(MetadataHandle&& other) noexcept : handle_(other.handle_) {
+    other.handle_ = nullptr;
+  }
+  MetadataHandle& operator=(MetadataHandle&& other) noexcept {
+    handle_ = other.handle_;
+    other.handle_ = nullptr;
+    return *this;
+  }
+
+  explicit MetadataHandle(const absl::Status& status) {
+    handle_ = GetContext<Arena>()->New<T>(GetContext<Arena>());
+    handle_->Set(GrpcStatusMetadata(),
+                 static_cast<grpc_status_code>(status.code()));
+    if (status.ok()) return;
+    handle_->Set(GrpcMessageMetadata(),
+                 Slice::FromCopiedString(status.message()));
+  }
+
+  T* operator->() const { return handle_; }
+  bool has_value() const { return handle_ != nullptr; }
+  T* get() const { return handle_; }
+
+  static MetadataHandle TestOnlyWrap(T* p) { return MetadataHandle(p); }
+
+ private:
+  friend class promise_filter_detail::BaseCallData;
+
+  explicit MetadataHandle(T* handle) : handle_(handle) {}
+  T* Unwrap() {
+    T* result = handle_;
+    handle_ = nullptr;
+    return result;
+  }
+
+  T* handle_ = nullptr;
+};
+
+// Trailing metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using TrailingMetadata = MetadataHandle<grpc_metadata_batch>;
+
+// Ok/not-ok check for trailing metadata, so that it can be used as result types
+// for TrySeq.
+inline bool IsStatusOk(const TrailingMetadata& m) {
+  return m->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN) ==
+         GRPC_STATUS_OK;
+}
+
+// Client initial metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ClientInitialMetadata = MetadataHandle<grpc_metadata_batch>;
+
+using NextPromiseFactory =
+    std::function<ArenaPromise<TrailingMetadata>(ClientInitialMetadata)>;
+}  // namespace grpc_core
+
 /* forward declarations */
 
 typedef struct grpc_transport grpc_transport;
@@ -278,8 +352,11 @@ struct grpc_transport_stream_op_batch_payload {
     /** Should be enqueued when initial metadata is ready to be processed. */
     grpc_closure* recv_initial_metadata_ready = nullptr;
     // If not NULL, will be set to true if trailing metadata is
-    // immediately available.  This may be a signal that we received a
-    // Trailers-Only response.
+    // immediately available. This may be a signal that we received a
+    // Trailers-Only response. The retry filter checks this to know whether to
+    // defer the decision to commit the call or not. The C++ callback API also
+    // uses this to set the success flag of OnReadInitialMetadataDone()
+    // callback.
     bool* trailing_metadata_available = nullptr;
     // If non-NULL, will be set by the transport to the peer string (a char*).
     // The transport retains ownership of the string.
@@ -353,6 +430,14 @@ typedef struct grpc_transport_op {
   void (*set_accept_stream_fn)(void* user_data, grpc_transport* transport,
                                const void* server_data) = nullptr;
   void* set_accept_stream_user_data = nullptr;
+  /** set the callback for accepting new streams based upon promises;
+      this is a permanent callback, unlike the other one-shot closures.
+      If true, the callback is set to set_make_promise_fn, with its
+      user_data argument set to set_make_promise_data */
+  bool set_make_promise = false;
+  void (*set_make_promise_fn)(void* user_data, grpc_transport* transport,
+                              const void* server_data) = nullptr;
+  void* set_make_promise_user_data = nullptr;
   /** add this transport to a pollset */
   grpc_pollset* bind_pollset = nullptr;
   /** add this transport to a pollset_set */

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

@@ -36,6 +36,19 @@ typedef struct grpc_transport_vtable {
                      grpc_stream_refcount* refcount, const void* server_data,
                      grpc_core::Arena* arena);
 
+  /* Create a promise to execute one client call.
+     If this is non-null, it may be used in preference to
+     perform_stream_op.
+     If this is used in preference to perform_stream_op, the
+     following can be omitted also:
+       - calling init_stream, destroy_stream, set_pollset, set_pollset_set
+       - allocation of memory for call data (sizeof_stream may be ignored)
+     There is an on-going migration to move all filters to providing this, and
+     then to drop perform_stream_op. */
+  grpc_core::ArenaPromise<grpc_core::TrailingMetadata> (*make_call_promise)(
+      grpc_transport* self, grpc_core::ClientInitialMetadata initial_metadata,
+      grpc_core::NextPromiseFactory next_promise_factory);
+
   /* implementation of grpc_transport_set_pollset */
   void (*set_pollset)(grpc_transport* self, grpc_stream* stream,
                       grpc_pollset* pollset);

data/src/core/lib/transport/transport_op_string.cc

@@ -25,6 +25,7 @@
 
 #include <vector>
 
+#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
@@ -40,24 +41,14 @@
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
 
-static void put_metadata_list(const grpc_metadata_batch& md,
-                              std::vector<std::string>* out) {
-  bool first = true;
-  md.Log([out, &first](absl::string_view key, absl::string_view value) {
-    if (!first) out->push_back(", ");
-    first = false;
-    out->push_back(absl::StrCat(key, "=", value));
-  });
-}
-
 std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op) {
   std::vector<std::string> out;
 
   if (op->send_initial_metadata) {
     out.push_back(" SEND_INITIAL_METADATA{");
-    put_metadata_list(*op->payload->send_initial_metadata.send_initial_metadata,
-                      &out);
+    out.push_back(op->payload->send_initial_metadata.send_initial_metadata
+                      ->DebugString());
     out.push_back("}");
   }
 
@@ -76,8 +67,8 @@ std::string grpc_transport_stream_op_batch_string(
 
   if (op->send_trailing_metadata) {
     out.push_back(" SEND_TRAILING_METADATA{");
-    put_metadata_list(
-        *op->payload->send_trailing_metadata.send_trailing_metadata, &out);
+    out.push_back(op->payload->send_trailing_metadata.send_trailing_metadata
+                      ->DebugString());
     out.push_back("}");
   }
 

data/src/core/lib/uri/uri_parser.cc

@@ -166,6 +166,10 @@ absl::Status MakeInvalidURIStatus(absl::string_view part_name,
 
 }  // namespace
 
+std::string URI::PercentEncodeAuthority(absl::string_view str) {
+  return PercentEncode(str, IsAuthorityChar);
+}
+
 std::string URI::PercentEncodePath(absl::string_view str) {
   return PercentEncode(str, IsPathChar);
 }

data/src/core/lib/uri/uri_parser.h

@@ -62,6 +62,7 @@ class URI {
   URI(URI&&) = default;
   URI& operator=(URI&&) = default;
 
+  static std::string PercentEncodeAuthority(absl::string_view str);
   static std::string PercentEncodePath(absl::string_view str);
 
   static std::string PercentDecode(absl::string_view str);