grpc 1.42.0 → 1.46.3

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

@@ -0,0 +1,89 @@
+// 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_SEQ_H
+#define GRPC_CORE_LIB_PROMISE_SEQ_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+template <typename T>
+struct SeqTraits {
+  using UnwrappedType = T;
+  using WrappedType = T;
+  template <typename Next>
+  static auto CallFactory(Next* next, T&& value)
+      -> decltype(next->Once(std::forward<T>(value))) {
+    return next->Once(std::forward<T>(value));
+  }
+  template <typename F, typename Elem>
+  static auto CallSeqFactory(F& f, Elem&& elem, T&& value)
+      -> decltype(f(std::forward<Elem>(elem), std::forward<T>(value))) {
+    return f(std::forward<Elem>(elem), std::forward<T>(value));
+  }
+  template <typename Result, typename PriorResult, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(PriorResult prior,
+                                            RunNext run_next) {
+    return run_next(std::move(prior));
+  }
+};
+
+template <typename... Fs>
+using Seq = BasicSeq<SeqTraits, Fs...>;
+
+}  // namespace promise_detail
+
+// Sequencing combinator.
+// Run the first promise.
+// Pass its result to the second, and run the returned promise.
+// Pass its result to the third, and run the returned promise.
+// etc
+// Return the final value.
+template <typename... Functors>
+promise_detail::Seq<Functors...> Seq(Functors... functors) {
+  return promise_detail::Seq<Functors...>(std::move(functors)...);
+}
+
+template <typename F>
+F Seq(F functor) {
+  return functor;
+}
+
+// Execute a sequence of operations of unknown length.
+// Asynchronously:
+//   for (element in (begin, end)) {
+//     argument = wait_for factory(element, argument);
+//   }
+//   return argument;
+template <typename Iter, typename Factory, typename Argument>
+promise_detail::BasicSeqIter<promise_detail::SeqTraits, Factory, Argument, Iter>
+SeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
+  return promise_detail::BasicSeqIter<promise_detail::SeqTraits, Factory,
+                                      Argument, Iter>(
+      begin, end, std::move(factory), std::move(argument));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_SEQ_H

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

@@ -0,0 +1,74 @@
+// 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/promise/sleep.h"
+
+namespace grpc_core {
+
+Sleep::Sleep(Timestamp deadline) : state_(new State(deadline)) {
+  GRPC_CLOSURE_INIT(&state_->on_timer, &OnTimer, state_, nullptr);
+}
+
+Sleep::~Sleep() {
+  if (state_ == nullptr) return;
+  {
+    MutexLock lock(&state_->mu);
+    switch (state_->stage) {
+      case Stage::kInitial:
+        state_->Unref();
+        break;
+      case Stage::kStarted:
+        grpc_timer_cancel(&state_->timer);
+        break;
+      case Stage::kDone:
+        break;
+    }
+  }
+  state_->Unref();
+}
+
+void Sleep::OnTimer(void* arg, grpc_error_handle) {
+  auto* state = static_cast<State*>(arg);
+  Waker waker;
+  {
+    MutexLock lock(&state->mu);
+    state->stage = Stage::kDone;
+    waker = std::move(state->waker);
+  }
+  waker.Wakeup();
+  state->Unref();
+}
+
+Poll<absl::Status> Sleep::operator()() {
+  MutexLock lock(&state_->mu);
+  switch (state_->stage) {
+    case Stage::kInitial:
+      if (state_->deadline <= ExecCtx::Get()->Now()) {
+        return absl::OkStatus();
+      }
+      state_->stage = Stage::kStarted;
+      grpc_timer_init(&state_->timer, state_->deadline, &state_->on_timer);
+      break;
+    case Stage::kStarted:
+      break;
+    case Stage::kDone:
+      return absl::OkStatus();
+  }
+  state_->waker = Activity::current()->MakeNonOwningWaker();
+  return Pending{};
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,66 @@
+// 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_SLEEP_H
+#define GRPC_CORE_LIB_PROMISE_SLEEP_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Promise that sleeps until a deadline and then finishes.
+class Sleep {
+ public:
+  explicit Sleep(Timestamp deadline);
+  ~Sleep();
+
+  Sleep(const Sleep&) = delete;
+  Sleep& operator=(const Sleep&) = delete;
+  Sleep(Sleep&& other) noexcept : state_(other.state_) {
+    other.state_ = nullptr;
+  }
+  Sleep& operator=(Sleep&& other) noexcept {
+    std::swap(state_, other.state_);
+    return *this;
+  }
+
+  Poll<absl::Status> operator()();
+
+ private:
+  static void OnTimer(void* arg, grpc_error_handle error);
+
+  enum class Stage { kInitial, kStarted, kDone };
+  struct State {
+    explicit State(Timestamp deadline) : deadline(deadline) {}
+    RefCount refs{2};
+    const Timestamp deadline;
+    grpc_timer timer;
+    grpc_closure on_timer;
+    Mutex mu;
+    Stage stage ABSL_GUARDED_BY(mu) = Stage::kInitial;
+    Waker waker ABSL_GUARDED_BY(mu);
+    void Unref() {
+      if (refs.Unref()) delete this;
+    }
+  };
+  State* state_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_SLEEP_H

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

@@ -0,0 +1,157 @@
+// 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_TRY_SEQ_H
+#define GRPC_CORE_LIB_PROMISE_TRY_SEQ_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+template <typename T, typename Ignored = void>
+struct TrySeqTraitsWithSfinae {
+  using UnwrappedType = T;
+  using WrappedType = absl::StatusOr<T>;
+  template <typename Next>
+  static auto CallFactory(Next* next, T&& value)
+      -> decltype(next->Once(std::forward<T>(value))) {
+    return next->Once(std::forward<T>(value));
+  }
+  template <typename F, typename Elem>
+  static auto CallSeqFactory(F& f, Elem&& elem, T&& value)
+      -> decltype(f(std::forward<Elem>(elem), std::forward<T>(value))) {
+    return f(std::forward<Elem>(elem), std::forward<T>(value));
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
+    return run_next(std::move(prior));
+  }
+};
+
+template <typename T>
+struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
+  using UnwrappedType = T;
+  using WrappedType = absl::StatusOr<T>;
+  template <typename Next>
+  static auto CallFactory(Next* next, absl::StatusOr<T>&& status)
+      -> decltype(next->Once(std::move(*status))) {
+    return next->Once(std::move(*status));
+  }
+  template <typename F, typename Elem>
+  static auto CallSeqFactory(F& f, Elem&& elem, absl::StatusOr<T> value)
+      -> decltype(f(std::forward<Elem>(elem), std::move(*value))) {
+    return f(std::forward<Elem>(elem), std::move(*value));
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(absl::StatusOr<T> prior,
+                                            RunNext run_next) {
+    if (!prior.ok()) return Result(prior.status());
+    return run_next(std::move(prior));
+  }
+};
+// If there exists a function 'IsStatusOk(const T&) -> bool' then we assume that
+// T is a status type for the purposes of promise sequences, and a non-OK T
+// should terminate the sequence and return.
+template <typename T>
+struct TrySeqTraitsWithSfinae<
+    T, absl::enable_if_t<
+           std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value,
+           void>> {
+  using UnwrappedType = void;
+  using WrappedType = T;
+  template <typename Next>
+  static auto CallFactory(Next* next, T&&) -> decltype(next->Once()) {
+    return next->Once();
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
+    if (!IsStatusOk(prior)) return Result(std::move(prior));
+    return run_next(std::move(prior));
+  }
+};
+template <>
+struct TrySeqTraitsWithSfinae<absl::Status> {
+  using UnwrappedType = void;
+  using WrappedType = absl::Status;
+  template <typename Next>
+  static auto CallFactory(Next* next, absl::Status&&)
+      -> decltype(next->Once()) {
+    return next->Once();
+  }
+  template <typename Result, typename RunNext>
+  static Poll<Result> CheckResultAndRunNext(absl::Status prior,
+                                            RunNext run_next) {
+    if (!prior.ok()) return Result(std::move(prior));
+    return run_next(std::move(prior));
+  }
+};
+
+template <typename T>
+using TrySeqTraits = TrySeqTraitsWithSfinae<T>;
+
+template <typename... Fs>
+using TrySeq = BasicSeq<TrySeqTraits, Fs...>;
+
+}  // namespace promise_detail
+
+// Try a sequence of operations.
+// * Run the first functor as a promise.
+// * Feed its success result into the second functor to create a promise,
+//   then run that.
+// * ...
+// * Feed the second-final success result into the final functor to create a
+//   promise, then run that, with the overall success result being that
+//   promises success result.
+// If any step fails, fail everything.
+// Functors can return StatusOr<> to signal that a value is fed forward, or
+// Status to indicate only success/failure. In the case of returning Status,
+// the construction functors take no arguments.
+template <typename... Functors>
+promise_detail::TrySeq<Functors...> TrySeq(Functors... functors) {
+  return promise_detail::TrySeq<Functors...>(std::move(functors)...);
+}
+
+// Try a sequence of operations of unknown length.
+// Asynchronously:
+//   for (element in (begin, end)) {
+//     auto r = wait_for factory(element, argument);
+//     if (!r.ok()) return r;
+//     argument = *r;
+//   }
+//   return argument;
+template <typename Iter, typename Factory, typename Argument>
+promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory, Argument,
+                             Iter>
+TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
+  return promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory,
+                                      Argument, Iter>(
+      begin, end, std::move(factory), std::move(argument));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_TRY_SEQ_H

data/src/core/{ext/filters/client_channel → lib/resolver}/resolver.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/resolver.h"
+#include "src/core/lib/resolver/resolver.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
                                                            "resolver_refcount");
@@ -38,35 +38,28 @@ Resolver::Resolver()
 // Resolver::Result
 //
 
-Resolver::Result::~Result() {
-  GRPC_ERROR_UNREF(service_config_error);
-  grpc_channel_args_destroy(args);
-}
+Resolver::Result::~Result() { grpc_channel_args_destroy(args); }
 
-Resolver::Result::Result(const Result& other) {
-  addresses = other.addresses;
-  service_config = other.service_config;
-  service_config_error = GRPC_ERROR_REF(other.service_config_error);
-  args = grpc_channel_args_copy(other.args);
-}
+Resolver::Result::Result(const Result& other)
+    : addresses(other.addresses),
+      service_config(other.service_config),
+      resolution_note(other.resolution_note),
+      args(grpc_channel_args_copy(other.args)) {}
 
-Resolver::Result::Result(Result&& other) noexcept {
-  addresses = std::move(other.addresses);
-  service_config = std::move(other.service_config);
-  service_config_error = other.service_config_error;
-  other.service_config_error = GRPC_ERROR_NONE;
-  args = other.args;
+Resolver::Result::Result(Result&& other) noexcept
+    : addresses(std::move(other.addresses)),
+      service_config(std::move(other.service_config)),
+      resolution_note(std::move(other.resolution_note)),
+      // TODO(roth): Use std::move() once channel args is converted to C++.
+      args(other.args) {
   other.args = nullptr;
 }
 
 Resolver::Result& Resolver::Result::operator=(const Result& other) {
-  if (&other == this) {
-    return *this;
-  }
+  if (&other == this) return *this;
   addresses = other.addresses;
   service_config = other.service_config;
-  GRPC_ERROR_UNREF(service_config_error);
-  service_config_error = GRPC_ERROR_REF(other.service_config_error);
+  resolution_note = other.resolution_note;
   grpc_channel_args_destroy(args);
   args = grpc_channel_args_copy(other.args);
   return *this;
@@ -75,9 +68,8 @@ Resolver::Result& Resolver::Result::operator=(const Result& other) {
 Resolver::Result& Resolver::Result::operator=(Result&& other) noexcept {
   addresses = std::move(other.addresses);
   service_config = std::move(other.service_config);
-  GRPC_ERROR_UNREF(service_config_error);
-  service_config_error = other.service_config_error;
-  other.service_config_error = GRPC_ERROR_NONE;
+  resolution_note = std::move(other.resolution_note);
+  // TODO(roth): Use std::move() once channel args is converted to C++.
   grpc_channel_args_destroy(args);
   args = other.args;
   other.args = nullptr;

data/src/core/{ext/filters/client_channel → lib/resolver}/resolver.h

@@ -1,34 +1,32 @@
-/*
- *
- * Copyright 2015 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_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H
+//
+// Copyright 2015 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_RESOLVER_RESOLVER_H
+#define GRPC_CORE_LIB_RESOLVER_RESOLVER_H
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
+
 #include <grpc/impl/codegen/grpc_types.h>
 
-#include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/ext/service_config/service_config.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/service_config/service_config.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
 
@@ -53,13 +51,23 @@ class Resolver : public InternallyRefCounted<Resolver> {
  public:
   /// Results returned by the resolver.
   struct Result {
-    ServerAddressList addresses;
-    RefCountedPtr<ServiceConfig> service_config;
-    grpc_error_handle service_config_error = GRPC_ERROR_NONE;
+    /// A list of addresses, or an error.
+    absl::StatusOr<ServerAddressList> addresses;
+    /// A service config, or an error.
+    absl::StatusOr<RefCountedPtr<ServiceConfig>> service_config = nullptr;
+    /// An optional human-readable note describing context about the resolution,
+    /// to be passed along to the LB policy for inclusion in RPC failure status
+    /// messages in cases where neither \a addresses nor \a service_config
+    /// has a non-OK status.  For example, a resolver that returns an empty
+    /// address list but a valid service config may set to this to something
+    /// like "no DNS entries found for <name>".
+    std::string resolution_note;
+    // TODO(roth): Before making this a public API, figure out a way to
+    // avoid exposing channel args this way.
     const grpc_channel_args* args = nullptr;
 
-    // TODO(roth): Remove everything below once grpc_error and
-    // grpc_channel_args are convert to copyable and movable C++ objects.
+    // TODO(roth): Remove everything below once grpc_channel_args is
+    // converted to a copyable and movable C++ object.
     Result() = default;
     ~Result();
     Result(const Result& other);
@@ -74,17 +82,11 @@ class Resolver : public InternallyRefCounted<Resolver> {
    public:
     virtual ~ResultHandler() {}
 
-    /// Returns a result to the channel.
-    /// Takes ownership of \a result.args.
-    virtual void ReturnResult(Result result) = 0;  // NOLINT
-
-    /// Returns a transient error to the channel.
-    /// If the resolver does not set the GRPC_ERROR_INT_GRPC_STATUS
-    /// attribute on the error, calls will be failed with status UNKNOWN.
-    virtual void ReturnError(grpc_error_handle error) = 0;
-
-    // TODO(yashkt): As part of the service config error handling
-    // changes, add a method to parse the service config JSON string.
+    /// Reports a result to the channel.
+    // TODO(roth): Add a mechanism for the resolver to get back a signal
+    // indicating if the result was accepted by the LB policy, so that it
+    // knows whether to go into backoff to retry to resolution.
+    virtual void ReportResult(Result result) = 0;  // NOLINT
   };
 
   // Not copyable nor movable.
@@ -113,9 +115,6 @@ class Resolver : public InternallyRefCounted<Resolver> {
   /// Resets the re-resolution backoff, if any.
   /// This needs to be implemented only by pull-based implementations;
   /// for push-based implementations, it will be a no-op.
-  /// TODO(roth): Pull the backoff code out of resolver and into
-  /// client_channel, so that it can be shared across resolver
-  /// implementations.  At that point, this method can go away.
   virtual void ResetBackoffLocked() {}
 
   // Note: This must be invoked while holding the work_serializer.
@@ -133,4 +132,4 @@ class Resolver : public InternallyRefCounted<Resolver> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H */
+#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_H