grpc 1.45.0 → 1.47.0

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -225,11 +225,13 @@ static grpc_error_handle prepare_socket(SOCKET sock,
 
 failure:
   GPR_ASSERT(error != GRPC_ERROR_NONE);
+  auto addr_uri = grpc_sockaddr_to_uri(addr);
   grpc_error_set_int(
-      grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Failed to prepare server socket", &error, 1),
-                         GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_sockaddr_to_uri(addr)),
+      grpc_error_set_str(
+          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+              "Failed to prepare server socket", &error, 1),
+          GRPC_ERROR_STR_TARGET_ADDRESS,
+          addr_uri.ok() ? *addr_uri : addr_uri.status().ToString()),
       GRPC_ERROR_INT_FD, (intptr_t)sock);
   GRPC_ERROR_UNREF(error);
   if (sock != INVALID_SOCKET) closesocket(sock);
@@ -347,7 +349,13 @@ static void on_accept(void* arg, grpc_error_handle error) {
       peer_name.len = (size_t)peer_name_len;
       std::string peer_name_string;
       if (!err) {
-        peer_name_string = grpc_sockaddr_to_uri(&peer_name);
+        auto addr_uri = grpc_sockaddr_to_uri(&peer_name);
+        if (addr_uri.ok()) {
+          peer_name_string = addr_uri.value();
+        } else {
+          gpr_log(GPR_ERROR, "invalid peer name: %s",
+                  addr_uri.status().ToString().c_str());
+        }
       } else {
         char* utf8_message = gpr_format_message(WSAGetLastError());
         gpr_log(GPR_ERROR, "getpeername error: %s", utf8_message);

data/src/core/lib/iomgr/tcp_windows.cc

@@ -31,6 +31,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -237,7 +238,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 #define DEFAULT_TARGET_READ_SIZE 8192
 #define MAX_WSABUF_COUNT 16
 static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
-                     grpc_closure* cb, bool urgent) {
+                     grpc_closure* cb, bool urgent, int /*min_progress_size*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* handle = tcp->socket;
   grpc_winsocket_callback_info* info = &handle->read_info;
@@ -344,7 +345,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
 
 /* Initiates a write. */
 static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                      grpc_closure* cb, void* arg) {
+                      grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->write_info;
@@ -517,12 +518,14 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
   GRPC_CLOSURE_INIT(&tcp->on_write, on_write, tcp, grpc_schedule_on_exec_ctx);
   grpc_resolved_address resolved_local_addr;
   resolved_local_addr.len = sizeof(resolved_local_addr.addr);
+  absl::StatusOr<std::string> addr_uri;
   if (getsockname(tcp->socket->socket,
                   reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
+                  &resolved_local_addr.len) < 0 ||
+      !(addr_uri = grpc_sockaddr_to_uri(&resolved_local_addr)).ok()) {
     tcp->local_address = "";
   } else {
-    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr).value();
   }
   tcp->peer_string = std::string(peer_string);
   grpc_slice_buffer_init(&tcp->last_read_buffer);

data/src/core/lib/json/json.h

@@ -21,10 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdlib.h>
-
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/strings/string_view.h"

data/src/core/lib/json/json_reader.cc

@@ -18,15 +18,23 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
+#include <inttypes.h>
+#include <stdlib.h>
 
+#include <algorithm>
+#include <map>
 #include <string>
+#include <utility>
+#include <vector>
 
+#include "absl/base/attributes.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 #define GRPC_JSON_MAX_DEPTH 255

data/src/core/lib/json/json_util.cc

@@ -20,9 +20,12 @@
 
 #include "src/core/lib/json/json_util.h"
 
+#include <string.h>
+
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
 
@@ -30,6 +33,10 @@ bool ParseDurationFromJson(const Json& field, Duration* duration) {
   if (field.type() != Json::Type::STRING) return false;
   size_t len = field.string_value().size();
   if (field.string_value()[len - 1] != 's') return false;
+  if (field.string_value() == Duration::Infinity().ToJsonString()) {
+    *duration = Duration::Infinity();
+    return true;
+  }
   UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
   *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf.get(), '.');

data/src/core/lib/json/json_util.h

@@ -21,10 +21,19 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -45,9 +54,9 @@ bool ExtractJsonNumber(const Json& json, absl::string_view field_name,
                        NumericType* output,
                        std::vector<grpc_error_handle>* error_list) {
   static_assert(std::is_integral<NumericType>::value, "Integral required");
-  if (json.type() != Json::Type::NUMBER) {
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("field:", field_name, " error:type should be NUMBER")));
+  if (json.type() != Json::Type::NUMBER && json.type() != Json::Type::STRING) {
+    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "field:", field_name, " error:type should be NUMBER or STRING")));
     return false;
   }
   if (!absl::SimpleAtoi(json.string_value(), output)) {

data/src/core/lib/json/json_writer.cc

@@ -18,8 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
 #include <stdlib.h>
-#include <string.h>
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "absl/strings/string_view.h"
 

data/src/core/lib/promise/activity.cc

@@ -16,7 +16,7 @@
 
 #include "src/core/lib/promise/activity.h"
 
-#include "absl/base/attributes.h"
+#include <stddef.h>
 
 #include "src/core/lib/gprpp/atomic_utils.h"
 

data/src/core/lib/promise/activity.h

@@ -17,14 +17,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <atomic>
-#include <functional>
 #include <memory>
-#include <type_traits>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -150,13 +147,16 @@ class Activity : public Orphanable {
   // Set the current activity at construction, clean it up at destruction.
   class ScopedActivity {
    public:
-    explicit ScopedActivity(Activity* activity) {
-      GPR_ASSERT(g_current_activity_ == nullptr);
+    explicit ScopedActivity(Activity* activity)
+        : prior_activity_(g_current_activity_) {
       g_current_activity_ = activity;
     }
-    ~ScopedActivity() { g_current_activity_ = nullptr; }
+    ~ScopedActivity() { g_current_activity_ = prior_activity_; }
     ScopedActivity(const ScopedActivity&) = delete;
     ScopedActivity& operator=(const ScopedActivity&) = delete;
+
+   private:
+    Activity* const prior_activity_;
   };
 
  private:

data/src/core/lib/promise/arena_promise.h

@@ -17,8 +17,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
+#include <stdlib.h>
 
+#include <type_traits>
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+
+#include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
 
@@ -177,6 +183,10 @@ class ArenaPromise {
   // Expose the promise interface: a call operator that returns Poll<T>.
   Poll<T> operator()() { return impl_->PollOnce(); }
 
+  bool has_value() const {
+    return impl_ != arena_promise_detail::NullImpl<T>::Get();
+  }
+
  private:
   // Underlying impl object.
   arena_promise_detail::ImplInterface<T>* impl_ =

data/src/core/lib/promise/call_push_pull.h

@@ -0,0 +1,148 @@
+// Copyright 2022 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_PROMISE_CALL_PUSH_PULL_H
+#define GRPC_CORE_LIB_PROMISE_CALL_PUSH_PULL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <assert.h>
+
+#include <type_traits>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/gprpp/bitset.h"
+#include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+template <typename FMain, typename FPush, typename FPull>
+class CallPushPull {
+ public:
+  CallPushPull(FMain f_main, FPush f_push, FPull f_pull)
+      : push_(std::move(f_push)), pull_(std::move(f_pull)) {
+    Construct(&main_, std::move(f_main));
+  }
+
+  CallPushPull(const CallPushPull&) = delete;
+  CallPushPull& operator=(const CallPushPull&) = delete;
+  CallPushPull(CallPushPull&& other) noexcept
+      : done_(other.done_),
+        push_(std::move(other.push_)),
+        pull_(std::move(other.pull_)) {
+    assert(!done_.is_set(kDoneMain));
+    Construct(&main_, std::move(other.main_));
+  }
+
+  CallPushPull& operator=(CallPushPull&& other) noexcept {
+    assert(!done_.is_set(kDoneMain));
+    done_ = other.done_;
+    assert(!done_.is_set(kDoneMain));
+    push_ = std::move(other.push_);
+    main_ = std::move(other.main_);
+    pull_ = std::move(other.pull_);
+    return *this;
+  }
+
+  ~CallPushPull() {
+    if (done_.is_set(kDoneMain)) {
+      Destruct(&result_);
+    } else {
+      Destruct(&main_);
+    }
+  }
+
+  using Result =
+      typename PollTraits<decltype(std::declval<PromiseLike<FMain>>()())>::Type;
+
+  Poll<Result> operator()() {
+    if (!done_.is_set(kDonePush)) {
+      auto p = push_();
+      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
+        if (IsStatusOk(*status)) {
+          done_.set(kDonePush);
+        } else {
+          return Result(std::move(*status));
+        }
+      }
+    }
+    if (!done_.is_set(kDoneMain)) {
+      auto p = main_();
+      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
+        if (IsStatusOk(*status)) {
+          done_.set(kDoneMain);
+          Destruct(&main_);
+          Construct(&result_, std::move(*status));
+        } else {
+          return std::move(*status);
+        }
+      }
+    }
+    if (!done_.is_set(kDonePull)) {
+      auto p = pull_();
+      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
+        if (IsStatusOk(*status)) {
+          done_.set(kDonePull);
+        } else {
+          return Result(std::move(*status));
+        }
+      }
+    }
+    if (done_.all()) return std::move(result_);
+    return Pending{};
+  }
+
+ private:
+  enum { kDonePull = 0, kDoneMain = 1, kDonePush = 2 };
+  BitSet<3> done_;
+  GPR_NO_UNIQUE_ADDRESS PromiseLike<FPush> push_;
+  union {
+    PromiseLike<FMain> main_;
+    Result result_;
+  };
+  GPR_NO_UNIQUE_ADDRESS PromiseLike<FPull> pull_;
+};
+
+}  // namespace promise_detail
+
+// For promises representing calls a common pattern emerges:
+// There's a process pushing data down the stack, a process handling the main
+// call part, and a process pulling data back up the stack.
+//
+// This can reasonably be represented by the right combinations of TryJoins and
+// Maps, but since the structure is fundamental to the domain we introduce
+// this simple helper to make it easier to write the common case.
+//
+// It takes three promises: the main call, the push and the pull.
+// When polling, the push is polled first, then the main call (descending the
+// stack), then the pull (as we ascend once more).
+//
+// This strategy minimizes repolls.
+template <typename FMain, typename FPush, typename FPull>
+promise_detail::CallPushPull<FMain, FPush, FPull> CallPushPull(FMain f_main,
+                                                               FPush f_push,
+                                                               FPull f_pull) {
+  return promise_detail::CallPushPull<FMain, FPush, FPull>(
+      std::move(f_main), std::move(f_push), std::move(f_pull));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_CALL_PUSH_PULL_H

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

@@ -29,7 +29,7 @@ namespace grpc_core {
 // not contain any members, only exist.
 // The reason for avoiding this is that context types each use a thread local.
 template <typename T>
-struct ContextType;
+struct ContextType;  // IWYU pragma: keep
 
 namespace promise_detail {
 

data/src/core/lib/promise/detail/basic_seq.h

@@ -21,6 +21,7 @@
 #include <cassert>
 #include <new>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -29,13 +30,12 @@
 
 #include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/detail/switch.h"
 #include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 namespace promise_detail {
-template <typename F>
-class PromiseLike;
 
 // Helper for SeqState to evaluate some common types to all partial
 // specializations.

data/src/core/lib/promise/detail/promise_factory.h

@@ -23,7 +23,6 @@
 #include "absl/meta/type_traits.h"
 
 #include "src/core/lib/promise/detail/promise_like.h"
-#include "src/core/lib/promise/poll.h"
 
 // PromiseFactory is an adaptor class.
 //

data/src/core/lib/promise/detail/status.h

@@ -39,11 +39,12 @@ inline absl::Status IntoStatus(absl::Status* status) {
 }
 
 }  // namespace promise_detail
-}  // namespace grpc_core
 
 // Return true if the status represented by the argument is ok, false if not.
 // By implementing this function for other, non-absl::Status types, those types
 // can participate in TrySeq as result types that affect control flow.
 inline bool IsStatusOk(const absl::Status& status) { return status.ok(); }
 
+}  // namespace grpc_core
+
 #endif  // GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H

data/src/core/lib/promise/intra_activity_waiter.h

@@ -0,0 +1,49 @@
+// 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_PROMISE_INTRA_ACTIVITY_WAITER_H
+#define GRPC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Helper type to track wakeups between objects in the same activity.
+// Can be fairly fast as no ref counting or locking needs to occur.
+class IntraActivityWaiter {
+ public:
+  // Register for wakeup, return Pending(). If state is not ready to proceed,
+  // Promises should bottom out here.
+  Pending pending() {
+    waiting_ = true;
+    return Pending();
+  }
+  // Wake the activity
+  void Wake() {
+    if (waiting_) {
+      waiting_ = false;
+      Activity::current()->ForceImmediateRepoll();
+    }
+  }
+
+ private:
+  bool waiting_ = false;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_INTRA_ACTIVITY_WAITER_H

data/src/core/lib/promise/latch.h

@@ -0,0 +1,103 @@
+// 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_PROMISE_LATCH_H
+#define GRPC_CORE_LIB_PROMISE_LATCH_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/promise/intra_activity_waiter.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Latch provides a single set waitable object.
+// Initially the Latch is unset.
+// It can be waited upon by the Wait method, which produces a Promise that
+// resolves when the Latch is Set to a value of type T.
+template <typename T>
+class Latch {
+ public:
+  // This is the type of the promise returned by Wait.
+  class WaitPromise {
+   public:
+    Poll<T*> operator()() const {
+      if (latch_->has_value_) {
+        return &latch_->value_;
+      } else {
+        return latch_->waiter_.pending();
+      }
+    }
+
+   private:
+    friend class Latch;
+    explicit WaitPromise(Latch* latch) : latch_(latch) {}
+    Latch* latch_;
+  };
+
+  Latch() = default;
+  Latch(const Latch&) = delete;
+  Latch& operator=(const Latch&) = delete;
+  Latch(Latch&& other) noexcept
+      : value_(std::move(other.value_)), has_value_(other.has_value_) {
+#ifndef NDEBUG
+    GPR_DEBUG_ASSERT(!other.has_had_waiters_);
+#endif
+  }
+  Latch& operator=(Latch&& other) noexcept {
+#ifndef NDEBUG
+    GPR_DEBUG_ASSERT(!other.has_had_waiters_);
+#endif
+    value_ = std::move(other.value_);
+    has_value_ = other.has_value_;
+    return *this;
+  }
+
+  // Produce a promise to wait for a value from this latch.
+  WaitPromise Wait() {
+#ifndef NDEBUG
+    has_had_waiters_ = true;
+#endif
+    return WaitPromise(this);
+  }
+
+  // Set the value of the latch. Can only be called once.
+  void Set(T value) {
+    GPR_DEBUG_ASSERT(!has_value_);
+    value_ = std::move(value);
+    has_value_ = true;
+    waiter_.Wake();
+  }
+
+ private:
+  // The value stored (if has_value_ is true), otherwise some random value, we
+  // don't care.
+  // Why not absl::optional<>? Writing things this way lets us compress
+  // has_value_ with waiter_ and leads to some significant memory savings for
+  // some scenarios.
+  GPR_NO_UNIQUE_ADDRESS T value_;
+  // True if we have a value set, false otherwise.
+  bool has_value_ = false;
+#ifndef NDEBUG
+  // Has this latch ever had waiters.
+  bool has_had_waiters_ = false;
+#endif
+  IntraActivityWaiter waiter_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_LATCH_H

data/src/core/lib/promise/loop.h

@@ -20,6 +20,7 @@
 #include <new>
 #include <type_traits>
 
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/variant.h"
 

data/src/core/lib/promise/race.h

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <tuple>
 #include <type_traits>
 
 #include "absl/types/variant.h"

data/src/core/lib/promise/seq.h

@@ -19,8 +19,6 @@
 
 #include <utility>
 
-#include "absl/types/variant.h"
-
 #include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/poll.h"
 

data/src/core/lib/promise/sleep.cc

@@ -16,6 +16,8 @@
 
 #include "src/core/lib/promise/sleep.h"
 
+#include "src/core/lib/iomgr/exec_ctx.h"
+
 namespace grpc_core {
 
 Sleep::Sleep(Timestamp deadline) : state_(new State(deadline)) {

data/src/core/lib/promise/sleep.h

@@ -17,6 +17,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <utility>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"