grpc 1.41.1 → 1.44.0.pre2

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

@@ -0,0 +1,48 @@
+// 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_EXEC_CTX_WAKEUP_SCHEDULER_H
+#define GRPC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+namespace grpc_core {
+
+// A callback scheduler for activities that works by scheduling callbacks on the
+// exec ctx.
+class ExecCtxWakeupScheduler {
+ public:
+  template <typename ActivityType>
+  void ScheduleWakeup(ActivityType* activity) {
+    GRPC_CLOSURE_INIT(
+        &closure_,
+        [](void* arg, grpc_error_handle) {
+          static_cast<ActivityType*>(arg)->RunScheduledWakeup();
+        },
+        activity, grpc_schedule_on_exec_ctx);
+    ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
+  }
+
+ private:
+  grpc_closure closure_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H

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

@@ -0,0 +1,108 @@
+// 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_LOOP_H
+#define GRPC_CORE_LIB_PROMISE_LOOP_H
+
+#include <grpc/support/port_platform.h>
+
+#include <new>
+#include <type_traits>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Special type - signals to loop to take another iteration, instead of
+// finishing
+struct Continue {};
+
+// Result of polling a loop promise - either Continue looping, or return a value
+// T
+template <typename T>
+using LoopCtl = absl::variant<Continue, T>;
+
+namespace promise_detail {
+
+template <typename T>
+struct LoopTraits;
+
+template <typename T>
+struct LoopTraits<LoopCtl<T>> {
+  using Result = T;
+};
+
+template <typename F>
+class Loop {
+ private:
+  using Factory = promise_detail::PromiseFactory<void, F>;
+  using Promise = decltype(std::declval<Factory>().Repeated());
+  using PromiseResult = typename Promise::Result;
+
+ public:
+  using Result = typename LoopTraits<PromiseResult>::Result;
+
+  explicit Loop(F f) : factory_(std::move(f)), promise_(factory_.Repeated()) {}
+  ~Loop() { promise_.~Promise(); }
+
+  Loop(Loop&& loop) noexcept
+      : factory_(std::move(loop.factory_)),
+        promise_(std::move(loop.promise_)) {}
+
+  Loop(const Loop& loop) = delete;
+  Loop& operator=(const Loop& loop) = delete;
+
+  Poll<Result> operator()() {
+    while (true) {
+      // Poll the inner promise.
+      auto promise_result = promise_();
+      // If it returns a value:
+      if (auto* p = absl::get_if<kPollReadyIdx>(&promise_result)) {
+        //  - then if it's Continue, destroy the promise and recreate a new one
+        //  from our factory.
+        if (absl::holds_alternative<Continue>(*p)) {
+          promise_.~Promise();
+          new (&promise_) Promise(factory_.Repeated());
+          continue;
+        }
+        //  - otherwise there's our result... return it out.
+        return absl::get<Result>(*p);
+      } else {
+        // Otherwise the inner promise was pending, so we are pending.
+        return Pending();
+      }
+    }
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Factory factory_;
+  GPR_NO_UNIQUE_ADDRESS union { GPR_NO_UNIQUE_ADDRESS Promise promise_; };
+};
+
+}  // namespace promise_detail
+
+// Looping combinator.
+// Expects F returns LoopCtl<T> - if it's Continue, then run the loop again -
+// otherwise yield the returned value as the result of the loop.
+template <typename F>
+promise_detail::Loop<F> Loop(F f) {
+  return promise_detail::Loop<F>(std::move(f));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_LOOP_H

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

@@ -0,0 +1,88 @@
+// 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_MAP_H
+#define GRPC_CORE_LIB_PROMISE_MAP_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Implementation of mapping combinator - use this via the free function below!
+// Promise is the type of promise to poll on, Fn is a function that takes the
+// result of Promise and maps it to some new type.
+template <typename Promise, typename Fn>
+class Map {
+ public:
+  Map(Promise promise, Fn fn)
+      : promise_(std::move(promise)), fn_(std::move(fn)) {}
+
+  using PromiseResult = typename PromiseLike<Promise>::Result;
+  using Result =
+      RemoveCVRef<decltype(std::declval<Fn>()(std::declval<PromiseResult>()))>;
+
+  Poll<Result> operator()() {
+    Poll<PromiseResult> r = promise_();
+    if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
+      return fn_(std::move(*p));
+    }
+    return Pending();
+  }
+
+ private:
+  PromiseLike<Promise> promise_;
+  Fn fn_;
+};
+
+}  // namespace promise_detail
+
+// Mapping combinator.
+// Takes a promise, and a synchronous function to mutate its result, and
+// returns a promise.
+template <typename Promise, typename Fn>
+promise_detail::Map<Promise, Fn> Map(Promise promise, Fn fn) {
+  return promise_detail::Map<Promise, Fn>(std::move(promise), std::move(fn));
+}
+
+// Callable that takes a tuple and returns one element
+template <size_t kElem>
+struct JustElem {
+  template <typename... A>
+  auto operator()(std::tuple<A...>&& t) const
+      -> decltype(std::get<kElem>(std::forward<std::tuple<A...>>(t))) {
+    return std::get<kElem>(std::forward<std::tuple<A...>>(t));
+  }
+  template <typename... A>
+  auto operator()(const std::tuple<A...>& t) const
+      -> decltype(std::get<kElem>(t)) {
+    return std::get<kElem>(t);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_MAP_H

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

@@ -0,0 +1,60 @@
+// 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_POLL_H
+#define GRPC_CORE_LIB_PROMISE_POLL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/types/variant.h"
+
+namespace grpc_core {
+
+// A type that signals a Promise is still pending and not yet completed.
+// Allows writing 'return Pending{}' and with automatic conversions gets
+// upgraded to a Poll<> object.
+struct Pending {
+  constexpr bool operator==(Pending) const { return true; }
+};
+
+// The result of polling a Promise once.
+//
+// Can be either pending - the Promise has not yet completed, or ready -
+// indicating that the Promise has completed AND should not be polled again.
+template <typename T>
+using Poll = absl::variant<Pending, T>;
+
+// Variant of Poll that serves as a ready value
+static constexpr size_t kPollReadyIdx = 1;
+
+// PollTraits tells us whether a type is Poll<> or some other type, and is
+// leveraged in the PromiseLike/PromiseFactory machinery to select the
+// appropriate implementation of those concepts based upon the return type of a
+// lambda, for example (via enable_if).
+template <typename T>
+struct PollTraits {
+  static constexpr bool is_poll() { return false; }
+};
+
+template <typename T>
+struct PollTraits<Poll<T>> {
+  using Type = T;
+  static constexpr bool is_poll() { return true; }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_POLL_H

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

@@ -0,0 +1,84 @@
+// 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_RACE_H
+#define GRPC_CORE_LIB_PROMISE_RACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <type_traits>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Implementation type for Race combinator.
+template <typename... Promises>
+class Race;
+
+template <typename Promise, typename... Promises>
+class Race<Promise, Promises...> {
+ public:
+  using Result = decltype(std::declval<Promise>()());
+
+  explicit Race(Promise promise, Promises... promises)
+      : promise_(std::move(promise)), next_(std::move(promises)...) {}
+
+  Result operator()() {
+    // Check our own promise.
+    auto r = promise_();
+    if (absl::holds_alternative<Pending>(r)) {
+      // Check the rest of them.
+      return next_();
+    }
+    // Return the first ready result.
+    return std::move(absl::get<kPollReadyIdx>(std::move(r)));
+  }
+
+ private:
+  // The Promise checked by this instance.
+  Promise promise_;
+  // We recursively expand to check the rest of the instances.
+  Race<Promises...> next_;
+};
+
+template <typename Promise>
+class Race<Promise> {
+ public:
+  using Result = decltype(std::declval<Promise>()());
+  explicit Race(Promise promise) : promise_(std::move(promise)) {}
+  Result operator()() { return promise_(); }
+
+ private:
+  Promise promise_;
+};
+
+}  // namespace promise_detail
+
+/// Run all the promises, return the first result that's available.
+/// If two results are simultaneously available, bias towards the first result
+/// listed.
+template <typename... Promises>
+promise_detail::Race<Promises...> Race(Promises... promises) {
+  return promise_detail::Race<Promises...>(std::move(promises)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_RACE_H

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

@@ -0,0 +1,71 @@
+// 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 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;
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_PROMISE_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/filters/client_channel/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