grpc 1.44.0.pre2 → 1.46.3

data/src/core/lib/avl/avl.h

@@ -22,6 +22,8 @@
 #include <algorithm>
 #include <memory>
 
+#include "absl/container/inlined_vector.h"
+
 namespace grpc_core {
 
 template <class K, class V = void>
@@ -32,8 +34,12 @@ class AVL {
   AVL Add(K key, V value) const {
     return AVL(AddKey(root_, std::move(key), std::move(value)));
   }
-  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
-  const V* Lookup(const K& key) const {
+  template <typename SomethingLikeK>
+  AVL Remove(const SomethingLikeK& key) const {
+    return AVL(RemoveKey(root_, key));
+  }
+  template <typename SomethingLikeK>
+  const V* Lookup(const SomethingLikeK& key) const {
     NodePtr n = Get(root_, key);
     return n ? &n->kv.second : nullptr;
   }
@@ -50,7 +56,36 @@ class AVL {
     ForEachImpl(root_.get(), std::forward<F>(f));
   }
 
-  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+  bool SameIdentity(const AVL& avl) const { return root_ == avl.root_; }
+
+  bool operator==(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q == nullptr;
+      if (q == nullptr) return false;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
+
+  bool operator<(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q != nullptr;
+      if (q == nullptr) return false;
+      if (p->kv < q->kv) return true;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
 
  private:
   struct Node;
@@ -68,6 +103,32 @@ class AVL {
   };
   NodePtr root_;
 
+  class Iterator {
+   public:
+    explicit Iterator(const NodePtr& root) {
+      auto* n = root.get();
+      while (n != nullptr) {
+        stack_.push_back(n);
+        n = n->left.get();
+      }
+    }
+    Node* current() const { return stack_.empty() ? nullptr : stack_.back(); }
+    void MoveNext() {
+      auto* n = stack_.back();
+      stack_.pop_back();
+      if (n->right != nullptr) {
+        n = n->right.get();
+        while (n != nullptr) {
+          stack_.push_back(n);
+          n = n->left.get();
+        }
+      }
+    }
+
+   private:
+    absl::InlinedVector<Node*, 8> stack_;
+  };
+
   explicit AVL(NodePtr root) : root_(std::move(root)) {}
 
   template <class F>
@@ -86,7 +147,8 @@ class AVL {
                                   1 + std::max(Height(left), Height(right)));
   }
 
-  static NodePtr Get(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr Get(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }
@@ -198,7 +260,8 @@ class AVL {
     return node;
   }
 
-  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr RemoveKey(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }

data/src/core/lib/backoff/backoff.cc

@@ -28,20 +28,17 @@ namespace grpc_core {
 
 BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
-grpc_millis BackOff::NextAttemptTime() {
+Timestamp BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
     return current_backoff_ + ExecCtx::Get()->Now();
   }
-  current_backoff_ = static_cast<grpc_millis>(
-      std::min(current_backoff_ * options_.multiplier(),
-               static_cast<double>(options_.max_backoff())));
-  const double jitter =
-      absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_,
-                    options_.jitter() * current_backoff_);
-  const grpc_millis next_timeout =
-      static_cast<grpc_millis>(current_backoff_ + jitter);
-  return next_timeout + ExecCtx::Get()->Now();
+  current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
+                              options_.max_backoff());
+  const Duration jitter = Duration::FromSecondsAsDouble(
+      absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_.seconds(),
+                    options_.jitter() * current_backoff_.seconds()));
+  return ExecCtx::Get()->Now() + current_backoff_ + jitter;
 }
 
 void BackOff::Reset() {

data/src/core/lib/backoff/backoff.h

@@ -37,7 +37,7 @@ class BackOff {
   explicit BackOff(const Options& options);
 
   /// Returns the time at which the next attempt should start.
-  grpc_millis NextAttemptTime();
+  Timestamp NextAttemptTime();
 
   /// Reset the backoff, so the next value returned by NextAttemptTime()
   /// will be the time of the second attempt (rather than the Nth).
@@ -45,7 +45,7 @@ class BackOff {
 
   class Options {
    public:
-    Options& set_initial_backoff(grpc_millis initial_backoff) {
+    Options& set_initial_backoff(Duration initial_backoff) {
       initial_backoff_ = initial_backoff;
       return *this;
     }
@@ -57,24 +57,24 @@ class BackOff {
       jitter_ = jitter;
       return *this;
     }
-    Options& set_max_backoff(grpc_millis max_backoff) {
+    Options& set_max_backoff(Duration max_backoff) {
       max_backoff_ = max_backoff;
       return *this;
     }
     /// how long to wait after the first failure before retrying
-    grpc_millis initial_backoff() const { return initial_backoff_; }
+    Duration initial_backoff() const { return initial_backoff_; }
     /// factor with which to multiply backoff after a failed retry
     double multiplier() const { return multiplier_; }
     /// amount to randomize backoffs
     double jitter() const { return jitter_; }
     /// maximum time between retries
-    grpc_millis max_backoff() const { return max_backoff_; }
+    Duration max_backoff() const { return max_backoff_; }
 
    private:
-    grpc_millis initial_backoff_;
+    Duration initial_backoff_;
     double multiplier_;
     double jitter_;
-    grpc_millis max_backoff_;
+    Duration max_backoff_;
   };  // class Options
 
  private:
@@ -82,7 +82,7 @@ class BackOff {
   absl::BitGen rand_gen_;
   bool initial_;
   /// current delay before retries
-  grpc_millis current_backoff_;
+  Duration current_backoff_;
 };
 
 }  // namespace grpc_core

data/src/core/lib/channel/call_finalization.h

@@ -0,0 +1,86 @@
+// 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_CHANNEL_CALL_FINALIZATION_H
+#define GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+// Call finalization context.
+// Sometimes a filter needs to perform some operation after the last byte of
+// data is flushed to the wire. This context is used to perform that
+// finalization.
+// Filters can register a finalizer by calling Add().
+// The finalizer will be called before the call is destroyed but after
+// the top level promise is completed.
+class CallFinalization {
+ public:
+  // Add a step to the finalization context.
+  // Takes a callable with a signature compatible with:
+  // (const grpc_call_final_info&) -> void.
+  // Finalizers are run in the reverse order they are added.
+  template <typename F>
+  void Add(F&& t) {
+    first_ =
+        GetContext<Arena>()->New<FuncFinalizer<F>>(std::forward<F>(t), first_);
+  }
+
+  void Run(const grpc_call_final_info* final_info) {
+    if (Finalizer* f = absl::exchange(first_, nullptr)) f->Run(final_info);
+  }
+
+ private:
+  // Base class for finalizer implementations.
+  class Finalizer {
+   public:
+    // Run the finalizer and call the destructor of this Finalizer.
+    virtual void Run(const grpc_call_final_info* final_info) = 0;
+
+   protected:
+    ~Finalizer() {}
+  };
+  // Specialization for callable objects.
+  template <typename F>
+  class FuncFinalizer final : public Finalizer {
+   public:
+    FuncFinalizer(F&& f, Finalizer* next)
+        : next_(next), f_(std::forward<F>(f)) {}
+
+    void Run(const grpc_call_final_info* final_info) override {
+      f_(final_info);
+      Finalizer* next = next_;
+      this->~FuncFinalizer();
+      if (next != nullptr) next->Run(final_info);
+    }
+
+   private:
+    Finalizer* next_;
+    F f_;
+  };
+  // The first finalizer in the chain.
+  Finalizer* first_ = nullptr;
+};
+
+template <>
+struct ContextType<CallFinalization> {};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H

data/src/core/lib/channel/call_tracer.h

@@ -59,9 +59,12 @@ class CallTracer {
     virtual void RecordReceivedInitialMetadata(
         grpc_metadata_batch* recv_initial_metadata, uint32_t flags) = 0;
     virtual void RecordReceivedMessage(const ByteStream& recv_message) = 0;
+    // If the call was cancelled before the recv_trailing_metadata op
+    // was started, recv_trailing_metadata and transport_stream_stats
+    // will be null.
     virtual void RecordReceivedTrailingMetadata(
         absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
-        const grpc_transport_stream_stats& transport_stream_stats) = 0;
+        const grpc_transport_stream_stats* transport_stream_stats) = 0;
     virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
     // Should be the last API call to the object. Once invoked, the tracer
     // library is free to destroy the object.

data/src/core/lib/channel/channel_args.cc

@@ -23,6 +23,7 @@
 #include <limits.h>
 #include <string.h>
 
+#include <map>
 #include <vector>
 
 #include "absl/strings/match.h"
@@ -36,6 +37,130 @@
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/match.h"
+
+namespace {
+
+int PointerCompare(void* a_ptr, const grpc_arg_pointer_vtable* a_vtable,
+                   void* b_ptr, const grpc_arg_pointer_vtable* b_vtable) {
+  int c = grpc_core::QsortCompare(a_ptr, b_ptr);
+  if (c == 0) return 0;
+  c = grpc_core::QsortCompare(a_vtable, b_vtable);
+  if (c != 0) return c;
+  return a_vtable->cmp(a_ptr, b_ptr);
+}
+
+}  // namespace
+
+namespace grpc_core {
+
+bool ChannelArgs::Pointer::operator==(const Pointer& rhs) const {
+  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) == 0;
+}
+
+bool ChannelArgs::Pointer::operator<(const Pointer& rhs) const {
+  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) < 0;
+}
+
+ChannelArgs::ChannelArgs() = default;
+
+ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
+  switch (arg.type) {
+    case GRPC_ARG_INTEGER:
+      return Set(arg.key, arg.value.integer);
+    case GRPC_ARG_STRING:
+      if (arg.value.string != nullptr) return Set(arg.key, arg.value.string);
+      return Set(arg.key, "");
+    case GRPC_ARG_POINTER:
+      return Set(arg.key,
+                 Pointer(arg.value.pointer.vtable->copy(arg.value.pointer.p),
+                         arg.value.pointer.vtable));
+  }
+  GPR_UNREACHABLE_CODE(return ChannelArgs());
+}
+
+ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
+  ChannelArgs result;
+  if (args != nullptr) {
+    for (size_t i = 0; i < args->num_args; i++) {
+      result = result.Set(args->args[i]);
+    }
+  }
+  return result;
+}
+
+const grpc_channel_args* ChannelArgs::ToC() const {
+  std::vector<grpc_arg> c_args;
+  args_.ForEach([&c_args](const std::string& key, const Value& value) {
+    char* name = const_cast<char*>(key.c_str());
+    c_args.push_back(Match(
+        value,
+        [name](int i) { return grpc_channel_arg_integer_create(name, i); },
+        [name](const std::string& s) {
+          return grpc_channel_arg_string_create(name,
+                                                const_cast<char*>(s.c_str()));
+        },
+        [name](const Pointer& p) {
+          return grpc_channel_arg_pointer_create(name, p.c_pointer(),
+                                                 p.c_vtable());
+        }));
+  });
+  return grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size());
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key, Value value) const {
+  return ChannelArgs(args_.Add(std::string(key), std::move(value)));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key,
+                             absl::string_view value) const {
+  return Set(key, std::string(value));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key, const char* value) const {
+  return Set(key, std::string(value));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key, std::string value) const {
+  return Set(key, Value(std::move(value)));
+}
+
+ChannelArgs ChannelArgs::Remove(absl::string_view key) const {
+  return ChannelArgs(args_.Remove(key));
+}
+
+absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  if (!absl::holds_alternative<int>(*v)) return absl::nullopt;
+  return absl::get<int>(*v);
+}
+
+absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
+    absl::string_view name) const {
+  auto ms = GetInt(name);
+  if (!ms.has_value()) return absl::nullopt;
+  if (*ms == INT_MAX) return Duration::Infinity();
+  if (*ms == INT_MIN) return Duration::NegativeInfinity();
+  return Duration::Milliseconds(*ms);
+}
+
+absl::optional<absl::string_view> ChannelArgs::GetString(
+    absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  if (!absl::holds_alternative<std::string>(*v)) return absl::nullopt;
+  return absl::get<std::string>(*v);
+}
+
+void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return nullptr;
+  if (!absl::holds_alternative<Pointer>(*v)) return nullptr;
+  return absl::get<Pointer>(*v).c_pointer();
+}
+
+}  // namespace grpc_core
 
 static grpc_arg copy_arg(const grpc_arg* src) {
   grpc_arg dst;
@@ -155,16 +280,8 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
     case GRPC_ARG_INTEGER:
       return grpc_core::QsortCompare(a->value.integer, b->value.integer);
     case GRPC_ARG_POINTER:
-      c = grpc_core::QsortCompare(a->value.pointer.p, b->value.pointer.p);
-      if (c != 0) {
-        c = grpc_core::QsortCompare(a->value.pointer.vtable,
-                                    b->value.pointer.vtable);
-        if (c == 0) {
-          c = a->value.pointer.vtable->cmp(a->value.pointer.p,
-                                           b->value.pointer.p);
-        }
-      }
-      return c;
+      return PointerCompare(a->value.pointer.p, a->value.pointer.vtable,
+                            b->value.pointer.p, b->value.pointer.vtable);
   }
   GPR_UNREACHABLE_CODE(return 0);
 }
@@ -368,19 +485,41 @@ std::string grpc_channel_args_string(const grpc_channel_args* args) {
 }
 
 namespace grpc_core {
-const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src) {
-  if (src == nullptr) return nullptr;
-  // Create result.
-  grpc_channel_args* dst =
-      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
-  dst->args =
-      static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * src->num_args));
-  dst->num_args = 0;
-  for (size_t i = 0; i < src->num_args; ++i) {
-    if (absl::StartsWith(src->args[i].key, "grpc.internal.")) continue;
-    dst->args[dst->num_args++] = copy_arg(&src->args[i]);
+ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src) {
+  if (src == nullptr) return ChannelArgs();
+  ChannelArgs output;
+  std::map<absl::string_view, std::vector<absl::string_view>>
+      concatenated_values;
+  for (size_t i = 0; i < src->num_args; i++) {
+    absl::string_view key = src->args[i].key;
+    // User-agent strings were traditionally multi-valued and concatenated.
+    // We preserve this behavior for backwards compatibility.
+    if (key == GRPC_ARG_PRIMARY_USER_AGENT_STRING ||
+        key == GRPC_ARG_SECONDARY_USER_AGENT_STRING) {
+      if (src->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                std::string(key).c_str());
+      } else {
+        concatenated_values[key].push_back(src->args[i].value.string);
+      }
+      continue;
+    } else if (absl::StartsWith(key, "grpc.internal.")) {
+      continue;
+    }
+    if (!output.Contains(key)) {
+      output = output.Set(src->args[i]);
+    } else {
+      // Traditional grpc_channel_args_find behavior was to pick the first
+      // value.
+      // For compatibility with existing users, we will do the same here.
+    }
   }
-  return dst;
+  // Concatenate the concatenated values.
+  for (const auto& concatenated_value : concatenated_values) {
+    output = output.Set(concatenated_value.first,
+                        absl::StrJoin(concatenated_value.second, " "));
+  }
+  return output;
 }
 }  // namespace grpc_core