grpc 1.70.1 → 1.71.0

data/src/core/util/status_helper.cc

@@ -156,12 +156,11 @@ void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value) {
                      absl::Cord(std::to_string(value)));
 }
 
-absl::optional<intptr_t> StatusGetInt(const absl::Status& status,
-                                      StatusIntProperty key) {
-  absl::optional<absl::Cord> p =
-      status.GetPayload(GetStatusIntPropertyUrl(key));
+std::optional<intptr_t> StatusGetInt(const absl::Status& status,
+                                     StatusIntProperty key) {
+  auto p = status.GetPayload(GetStatusIntPropertyUrl(key));
   if (p.has_value()) {
-    absl::optional<absl::string_view> sv = p->TryFlat();
+    auto sv = p->TryFlat();
     intptr_t value;
     if (sv.has_value()) {
       if (absl::SimpleAtoi(*sv, &value)) {
@@ -181,10 +180,9 @@ void StatusSetStr(absl::Status* status, StatusStrProperty key,
   status->SetPayload(GetStatusStrPropertyUrl(key), absl::Cord(value));
 }
 
-absl::optional<std::string> StatusGetStr(const absl::Status& status,
-                                         StatusStrProperty key) {
-  absl::optional<absl::Cord> p =
-      status.GetPayload(GetStatusStrPropertyUrl(key));
+std::optional<std::string> StatusGetStr(const absl::Status& status,
+                                        StatusStrProperty key) {
+  auto p = status.GetPayload(GetStatusStrPropertyUrl(key));
   if (p.has_value()) {
     return std::string(*p);
   }
@@ -199,12 +197,11 @@ void StatusSetTime(absl::Status* status, StatusTimeProperty key,
                      absl::Cord(std::move(time_str)));
 }
 
-absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
-                                         StatusTimeProperty key) {
-  absl::optional<absl::Cord> p =
-      status.GetPayload(GetStatusTimePropertyUrl(key));
+std::optional<absl::Time> StatusGetTime(const absl::Status& status,
+                                        StatusTimeProperty key) {
+  auto p = status.GetPayload(GetStatusTimePropertyUrl(key));
   if (p.has_value()) {
-    absl::optional<absl::string_view> sv = p->TryFlat();
+    auto sv = p->TryFlat();
     absl::Time time;
     if (sv.has_value()) {
       if (absl::ParseTime(absl::RFC3339_full, sv.value(), &time, nullptr)) {
@@ -227,8 +224,7 @@ void StatusAddChild(absl::Status* status, absl::Status child) {
   size_t buf_len = 0;
   char* buf = google_rpc_Status_serialize(msg, arena.ptr(), &buf_len);
   // Append (msg-length and msg) to children payload
-  absl::optional<absl::Cord> old_children =
-      status->GetPayload(kChildrenPropertyUrl);
+  auto old_children = status->GetPayload(kChildrenPropertyUrl);
   absl::Cord children;
   if (old_children.has_value()) {
     children = *old_children;
@@ -241,7 +237,7 @@ void StatusAddChild(absl::Status* status, absl::Status child) {
 }
 
 std::vector<absl::Status> StatusGetChildren(absl::Status status) {
-  absl::optional<absl::Cord> children = status.GetPayload(kChildrenPropertyUrl);
+  auto children = status.GetPayload(kChildrenPropertyUrl);
   return children.has_value() ? ParseChildren(*children)
                               : std::vector<absl::Status>();
 }
@@ -256,7 +252,7 @@ std::string StatusToString(const absl::Status& status) {
     absl::StrAppend(&head, ":", status.message());
   }
   std::vector<std::string> kvs;
-  absl::optional<absl::Cord> children;
+  std::optional<absl::Cord> children;
   status.ForEachPayload([&](absl::string_view type_url,
                             const absl::Cord& payload) {
     if (absl::StartsWith(type_url, kTypeUrlPrefix)) {
@@ -295,7 +291,7 @@ std::string StatusToString(const absl::Status& status) {
                                    absl::CHexEscape(payload_view), "\""));
       }
     } else {
-      absl::optional<absl::string_view> payload_view = payload.TryFlat();
+      auto payload_view = payload.TryFlat();
       std::string payload_str = absl::CHexEscape(
           payload_view.has_value() ? *payload_view : std::string(payload));
       kvs.push_back(absl::StrCat(type_url, ":\"", payload_str, "\""));
@@ -354,7 +350,7 @@ google_rpc_Status* StatusToProto(const absl::Status& status, upb_Arena* arena) {
     memcpy(type_url_buf, type_url.data(), type_url.size());
     google_protobuf_Any_set_type_url(
         any, upb_StringView_FromDataAndSize(type_url_buf, type_url.size()));
-    absl::optional<absl::string_view> v_view = payload.TryFlat();
+    auto v_view = payload.TryFlat();
     if (v_view.has_value()) {
       google_protobuf_Any_set_value(
           any, upb_StringView_FromDataAndSize(v_view->data(), v_view->size()));

data/src/core/util/status_helper.h

@@ -22,13 +22,13 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "src/core/util/debug_location.h"
 
 extern "C" {
@@ -92,15 +92,15 @@ void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value);
 
 /// Gets the int property from the status
 GRPC_MUST_USE_RESULT
-absl::optional<intptr_t> StatusGetInt(const absl::Status& status,
-                                      StatusIntProperty key);
+std::optional<intptr_t> StatusGetInt(const absl::Status& status,
+                                     StatusIntProperty key);
 
 /// Sets the str property to the status
 void StatusSetStr(absl::Status* status, StatusStrProperty key,
                   absl::string_view value);
 
 /// Gets the str property from the status
-GRPC_MUST_USE_RESULT absl::optional<std::string> StatusGetStr(
+GRPC_MUST_USE_RESULT std::optional<std::string> StatusGetStr(
     const absl::Status& status, StatusStrProperty key);
 
 /// Sets the time property to the status
@@ -108,7 +108,7 @@ void StatusSetTime(absl::Status* status, StatusTimeProperty key,
                    absl::Time time);
 
 /// Gets the time property from the status
-GRPC_MUST_USE_RESULT absl::optional<absl::Time> StatusGetTime(
+GRPC_MUST_USE_RESULT std::optional<absl::Time> StatusGetTime(
     const absl::Status& status, StatusTimeProperty key);
 
 /// Adds a child status to status

data/src/core/util/sync_abseil.cc

@@ -30,7 +30,6 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "src/core/util/crash.h"
 #include "src/core/util/time_util.h"
 
 void gpr_mu_init(gpr_mu* mu) {

data/src/core/util/table.h

@@ -155,19 +155,6 @@ void DestructIfNotNull(T* p) {
   if (p) p->~T();
 }
 
-// Helper function... just ignore the initializer list passed into it.
-// Allows doing 'statements' via parameter pack expansion in C++11 - given
-// template <typename... Ts>:
-//  do_these_things({(foo<Ts>(), 1)});
-// will execute foo<T>() for each T in Ts.
-// In this example we also leverage the comma operator to make the resultant
-// type of each statement be a consistent int so that C++ type deduction works
-// as we'd like (note that in the expression (a, 1) in C++, the 'result' of the
-// expression is the value after the right-most ',' -- in this case 1, with a
-// executed as a side effect.
-template <typename T>
-void do_these_things(std::initializer_list<T>) {}
-
 }  // namespace table_detail
 
 // A Table<Ts> is much like a tuple<optional<Ts>...> - a set of values that are
@@ -438,41 +425,39 @@ class Table {
   // destructor.
   template <size_t... I>
   void Destruct(absl::index_sequence<I...>) {
-    table_detail::do_these_things<int>(
-        {(table_detail::DestructIfNotNull(get<I>()), 1)...});
+    (table_detail::DestructIfNotNull(get<I>()), ...);
   }
 
   // For each field (element I=0, 1, ...) copy that field into this table -
   // or_clear as per CopyIf().
   template <bool or_clear, size_t... I>
   void Copy(absl::index_sequence<I...>, const Table& rhs) {
-    table_detail::do_these_things<int>({(CopyIf<or_clear, I>(rhs), 1)...});
+    (CopyIf<or_clear, I>(rhs), ...);
   }
 
   // For each field (element I=0, 1, ...) move that field into this table -
   // or_clear as per MoveIf().
   template <bool or_clear, size_t... I>
   void Move(absl::index_sequence<I...>, Table&& rhs) {
-    table_detail::do_these_things<int>(
-        {(MoveIf<or_clear, I>(std::forward<Table>(rhs)), 1)...});
+    (MoveIf<or_clear, I>(std::forward<Table>(rhs)), ...);
   }
 
   // For each field (element I=0, 1, ...) if that field is present, call f.
   template <typename F, size_t... I>
   void ForEachImpl(F f, absl::index_sequence<I...>) const {
-    table_detail::do_these_things<int>({(CallIf<I>(&f), 1)...});
+    (CallIf<I>(&f), ...);
   }
 
   // For each field (element I=0, 1, ...) if that field is present, call f. If
   // f returns false, remove the field from the table.
   template <typename F, size_t... I>
   void FilterInImpl(F f, absl::index_sequence<I...>) {
-    table_detail::do_these_things<int>({(FilterIf<I>(&f), 1)...});
+    (FilterIf<I>(&f), ...);
   }
 
   template <size_t... I>
   void ClearAllImpl(absl::index_sequence<I...>) {
-    table_detail::do_these_things<int>({(clear<I>(), 1)...});
+    (clear<I>(), ...);
   }
 
   // Bit field indicating which elements are set.

data/src/core/util/time.cc

@@ -84,7 +84,7 @@ GPR_ATTRIBUTE_NOINLINE std::pair<int64_t, gpr_cycle_counter> InitTime() {
     g_process_epoch_cycles.store(process_epoch_cycles,
                                  std::memory_order_relaxed);
   }
-  return std::make_pair(process_epoch_seconds, process_epoch_cycles);
+  return std::pair(process_epoch_seconds, process_epoch_cycles);
 }
 
 gpr_timespec StartTime() {

data/src/core/util/time.h

@@ -21,10 +21,10 @@
 #include <stdint.h>
 
 #include <limits>
+#include <optional>
 #include <ostream>
 #include <string>
 
-#include "absl/types/optional.h"
 #include "src/core/util/time_precise.h"
 #include "src/core/util/useful.h"
 
@@ -171,13 +171,13 @@ class ScopedTimeCache final : public Timestamp::ScopedSource {
   Timestamp Now() override;
 
   void InvalidateCache() override {
-    cached_time_ = absl::nullopt;
+    cached_time_ = std::nullopt;
     Timestamp::ScopedSource::InvalidateCache();
   }
   void TestOnlySetNow(Timestamp now) { cached_time_ = now; }
 
  private:
-  absl::optional<Timestamp> cached_time_;
+  std::optional<Timestamp> cached_time_;
 };
 
 // Duration represents a span of time.

data/src/core/util/time_precise.cc

@@ -28,7 +28,6 @@
 #include <algorithm>
 
 #include "absl/log/log.h"
-#include "src/core/util/crash.h"
 #include "src/core/util/time_precise.h"
 
 #ifndef GPR_CYCLE_COUNTER_CUSTOM

data/src/core/util/type_list.h

@@ -25,8 +25,64 @@ struct Typelist {
 
   template <typename C>
   using PushFront = Typelist<C, A...>;
+
+  template <typename C>
+  using PushBack = Typelist<A..., C>;
+};
+
+namespace typelist_detail {
+template <typename T>
+struct ReverseTpl;
+
+template <typename A>
+struct ReverseTpl<Typelist<A>> {
+  using Result = Typelist<A>;
 };
 
+template <typename A, typename... Rest>
+struct ReverseTpl<Typelist<A, Rest...>> {
+  using Result =
+      typename ReverseTpl<Typelist<Rest...>>::Result::template PushBack<A>;
+};
+}  // namespace typelist_detail
+
+template <typename... A>
+using Reverse = typename typelist_detail::ReverseTpl<Typelist<A...>>::Result;
+
+// A compile time list of values
+template <auto... A>
+struct Valuelist {
+  template <template <auto...> class T>
+  using Instantiate = T<A...>;
+
+  template <auto C>
+  using PushFront = Valuelist<C, A...>;
+
+  template <auto C>
+  using PushBack = Valuelist<A..., C>;
+};
+
+namespace valuelist_detail {
+template <typename T>
+struct ReverseTpl;
+
+template <auto A>
+struct ReverseTpl<Valuelist<A>> {
+  using Result = Valuelist<A>;
+};
+
+template <auto A, auto... Rest>
+struct ReverseTpl<Valuelist<A, Rest...>> {
+  using Result =
+      typename ReverseTpl<Valuelist<Rest...>>::Result::template PushBack<A>;
+};
+
+}  // namespace valuelist_detail
+
+template <auto... A>
+using ReverseValues =
+    typename valuelist_detail::ReverseTpl<Valuelist<A...>>::Result;
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_TYPE_LIST_H

data/src/core/util/uri.cc

@@ -261,9 +261,9 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
     for (absl::string_view query_param : absl::StrSplit(tmp_query, '&')) {
       const std::pair<absl::string_view, absl::string_view> possible_kv =
           absl::StrSplit(query_param, absl::MaxSplits('=', 1));
-      if (possible_kv.first.empty()) continue;
-      query_param_pairs.push_back({PercentDecode(possible_kv.first),
-                                   PercentDecode(possible_kv.second)});
+      auto& [key, value] = possible_kv;
+      if (key.empty()) continue;
+      query_param_pairs.push_back({PercentDecode(key), PercentDecode(value)});
     }
     if (offset == remaining.npos) {
       remaining = "";
@@ -348,7 +348,9 @@ struct QueryParameterFormatter {
 
 std::string URI::ToString() const {
   std::vector<std::string> parts = {PercentEncode(scheme_, IsSchemeChar), ":"};
-  if (!authority_.empty()) {
+  // If path starts with '//' we need to encode the authority to ensure that
+  // we can round-trip the URI through a parse/encode/parse loop.
+  if (!authority_.empty() || absl::StartsWith(path_, "//")) {
     parts.emplace_back("//");
     parts.emplace_back(PercentEncode(authority_, IsAuthorityChar));
   }

data/src/core/util/uri.h

@@ -89,6 +89,13 @@ class URI {
   // the wire in an HTTP request.
   std::string EncodedPathAndQueryParams() const;
 
+  bool operator==(const URI& other) const {
+    return scheme_ == other.scheme_ && authority_ == other.authority_ &&
+           path_ == other.path_ &&
+           query_parameter_pairs_ == other.query_parameter_pairs_ &&
+           fragment_ == other.fragment_;
+  }
+
  private:
   URI(std::string scheme, std::string authority, std::string path,
       std::vector<QueryParam> query_parameter_pairs, std::string fragment);

data/src/core/util/useful.h

@@ -19,11 +19,11 @@
 
 #include <cstddef>
 #include <limits>
+#include <variant>
 
 #include "absl/log/check.h"
 #include "absl/numeric/bits.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 
 /// useful utilities that don't belong anywhere else
 
@@ -66,12 +66,12 @@ int QsortCompare(const T& a, const T& b) {
 }
 
 template <typename... X>
-int QsortCompare(const absl::variant<X...>& a, const absl::variant<X...>& b) {
+int QsortCompare(const std::variant<X...>& a, const std::variant<X...>& b) {
   const int index = QsortCompare(a.index(), b.index());
   if (index != 0) return index;
-  return absl::visit(
+  return std::visit(
       [&](const auto& x) {
-        return QsortCompare(x, absl::get<absl::remove_cvref_t<decltype(x)>>(b));
+        return QsortCompare(x, std::get<absl::remove_cvref_t<decltype(x)>>(b));
       },
       a);
 }

data/src/core/util/validation_errors.cc

@@ -58,13 +58,13 @@ absl::Status ValidationErrors::status(absl::StatusCode code,
 std::string ValidationErrors::message(absl::string_view prefix) const {
   if (field_errors_.empty()) return "";
   std::vector<std::string> errors;
-  for (const auto& p : field_errors_) {
-    if (p.second.size() > 1) {
-      errors.emplace_back(absl::StrCat("field:", p.first, " errors:[",
-                                       absl::StrJoin(p.second, "; "), "]"));
+  for (const auto& [field, field_errors] : field_errors_) {
+    if (field_errors.size() > 1) {
+      errors.emplace_back(absl::StrCat("field:", field, " errors:[",
+                                       absl::StrJoin(field_errors, "; "), "]"));
     } else {
       errors.emplace_back(
-          absl::StrCat("field:", p.first, " error:", p.second[0]));
+          absl::StrCat("field:", field, " error:", field_errors[0]));
     }
   }
   return absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]");

data/src/core/util/wait_for_single_owner.h

@@ -0,0 +1,62 @@
+// Copyright 2024 The 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_SRC_CORE_UTIL_WAIT_FOR_SINGLE_OWNER_H
+#define GRPC_SRC_CORE_UTIL_WAIT_FOR_SINGLE_OWNER_H
+
+#include <memory>
+
+#include "absl/log/log.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/time.h"
+
+namespace grpc_core {
+
+// Waits until the use_count of the shared_ptr has reached 1 and returns,
+// destroying the object.
+//
+// Callers must first give up their ref, or this method will block forever.
+// Usage: WaitForSingleOwner(std::move(obj))
+template <typename T>
+void WaitForSingleOwner(std::shared_ptr<T> obj) {
+  WaitForSingleOwnerWithTimeout(std::move(obj), Duration::Hours(24));
+}
+
+// Waits until the use_count of the shared_ptr has reached 1 and returns,
+// destroying the object.
+//
+// This version will CRASH after the given timeout.
+// Usage: WaitForSingleOwnerWithTimeout(std::move(obj), Duration::Seconds(30));
+template <typename T>
+void WaitForSingleOwnerWithTimeout(std::shared_ptr<T> obj, Duration timeout) {
+  auto start = Timestamp::Now();
+  while (obj.use_count() > 1) {
+    auto elapsed = Timestamp::Now() - start;
+    auto remaining = timeout - elapsed;
+    if (remaining < Duration::Zero()) {
+      Crash("Timed out waiting for a single shared_ptr owner");
+    }
+    // To avoid log spam, wait a few seconds to begin logging the wait time.
+    if (elapsed >= Duration::Seconds(2)) {
+      LOG_EVERY_N_SEC(INFO, 2)
+          << "obj.use_count() = " << obj.use_count() << " timeout_remaining = "
+          << absl::FormatDuration(absl::Milliseconds(remaining.millis()));
+    }
+    absl::SleepFor(absl::Milliseconds(100));
+  }
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_WAIT_FOR_SINGLE_OWNER_H

data/src/core/util/windows/env.cc

@@ -29,14 +29,14 @@
 
 namespace grpc_core {
 
-absl::optional<std::string> GetEnv(const char* name) {
+std::optional<std::string> GetEnv(const char* name) {
   auto tname = CharToTchar(name);
   DWORD ret = GetEnvironmentVariable(tname.c_str(), NULL, 0);
-  if (ret == 0) return absl::nullopt;
+  if (ret == 0) return std::nullopt;
   std::unique_ptr<TCHAR[]> tresult(new TCHAR[ret]);
   ret =
       GetEnvironmentVariable(tname.c_str(), tresult.get(), ret * sizeof(TCHAR));
-  if (ret == 0) return absl::nullopt;
+  if (ret == 0) return std::nullopt;
   return TcharToChar(tresult.get());
 }
 

data/src/core/util/windows/sync.cc

@@ -27,7 +27,6 @@
 #include <grpc/support/time.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 void gpr_mu_init(gpr_mu* mu) {
   InitializeCriticalSection(&mu->cs);

data/src/core/util/windows/time.cc

@@ -28,7 +28,6 @@
 #include <sys/timeb.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 #include "src/core/util/time_precise.h"
 
 static LARGE_INTEGER g_start_time = []() {