grpc 1.35.0 → 1.38.0

data/src/core/lib/gprpp/status_helper.h

@@ -0,0 +1,180 @@
+//
+//
+// Copyright 2021 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_CORE_LIB_GPRPP_STATUS_HELPER_H
+#define GRPC_CORE_LIB_GPRPP_STATUS_HELPER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/status.h"
+#include "absl/time/time.h"
+
+#include "src/core/lib/gprpp/debug_location.h"
+
+extern "C" {
+struct google_rpc_Status;
+struct upb_arena;
+}
+
+namespace grpc_core {
+
+/// This enum should have the same value of grpc_error_ints
+// TODO(veblush): Use camel-case names once migration to absl::Status is done.
+enum class StatusIntProperty {
+  /// 'errno' from the operating system
+  kErrorNo,
+  /// __LINE__ from the call site creating the error
+  kFileLine,
+  /// stream identifier: for errors that are associated with an individual
+  /// wire stream
+  kStreamId,
+  /// grpc status code representing this error
+  // TODO(veblush): Remove this after grpc_error is replaced with absl::Status
+  kRpcStatus,
+  /// offset into some binary blob (usually represented by
+  /// RAW_BYTES) where the error occurred
+  kOffset,
+  /// context sensitive index associated with the error
+  kIndex,
+  /// context sensitive size associated with the error
+  kSize,
+  /// http2 error code associated with the error (see the HTTP2 RFC)
+  kHttp2Error,
+  /// TSI status code associated with the error
+  kTsiCode,
+  /// WSAGetLastError() reported when this error occurred
+  kWsaError,
+  /// File descriptor associated with this error
+  kFd,
+  /// HTTP status (i.e. 404)
+  kHttpStatus,
+  /// chttp2: did the error occur while a write was in progress
+  kOccurredDuringWrite,
+  /// channel connectivity state associated with the error
+  ChannelConnectivityState,
+  /// LB policy drop
+  kLbPolicyDrop,
+};
+
+/// This enum should have the same value of grpc_error_strs
+// TODO(veblush): Use camel-case names once migration to absl::Status is done.
+enum class StatusStrProperty {
+  /// top-level textual description of this error
+  kDescription,
+  /// source file in which this error occurred
+  kFile,
+  /// operating system description of this error
+  kOsError,
+  /// syscall that generated this error
+  kSyscall,
+  /// peer that we were trying to communicate when this error occurred
+  kTargetAddress,
+  /// grpc status message associated with this error
+  kGrpcMessage,
+  /// hex dump (or similar) with the data that generated this error
+  kRawBytes,
+  /// tsi error string associated with this error
+  kTsiError,
+  /// filename that we were trying to read/write when this error occurred
+  kFilename,
+  /// key associated with the error
+  kKey,
+  /// value associated with the error
+  kValue,
+};
+
+/// This enum should have the same value of grpc_error_times
+enum class StatusTimeProperty {
+  /// timestamp of error creation
+  kCreated,
+};
+
+/// Creates a status with given additional information
+absl::Status StatusCreate(
+    absl::StatusCode code, absl::string_view msg, const DebugLocation& location,
+    std::initializer_list<absl::Status> children) GRPC_MUST_USE_RESULT;
+
+/// Sets the int property to the status
+void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value);
+
+/// Gets the int property from the status
+absl::optional<intptr_t> StatusGetInt(
+    const absl::Status& status, StatusIntProperty key) GRPC_MUST_USE_RESULT;
+
+/// 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
+absl::optional<std::string> StatusGetStr(
+    const absl::Status& status, StatusStrProperty key) GRPC_MUST_USE_RESULT;
+
+/// Sets the time property to the status
+void StatusSetTime(absl::Status* status, StatusTimeProperty key,
+                   absl::Time time);
+
+/// Gets the time property from the status
+absl::optional<absl::Time> StatusGetTime(
+    const absl::Status& status, StatusTimeProperty key) GRPC_MUST_USE_RESULT;
+
+/// Adds a child status to status
+void StatusAddChild(absl::Status* status, absl::Status child);
+
+/// Returns all children status from a status
+std::vector<absl::Status> StatusGetChildren(absl::Status status)
+    GRPC_MUST_USE_RESULT;
+
+/// Returns a string representation from status
+/// Error status will be like
+///   STATUS[:MESSAGE] [{PAYLOADS[, children:[CHILDREN-STATUS-LISTS]]}]
+/// e.g.
+///   CANCELLATION:SampleMessage {errno:'2021', line:'54', children:[ABORTED]}
+std::string StatusToString(const absl::Status& status) GRPC_MUST_USE_RESULT;
+
+namespace internal {
+
+/// Builds a upb message, google_rpc_Status from a status
+/// This is for internal implementation & test only
+google_rpc_Status* StatusToProto(absl::Status status,
+                                 upb_arena* arena) GRPC_MUST_USE_RESULT;
+
+/// Builds a status from a upb message, google_rpc_Status
+/// This is for internal implementation & test only
+absl::Status StatusFromProto(google_rpc_Status* msg) GRPC_MUST_USE_RESULT;
+
+/// The same value of grpc_core::internal::StatusAllocPtr(absl::OkStatus())
+static constexpr uintptr_t kOkStatusPtr = 0;
+
+/// Returns ptr where the given status is copied into.
+/// This ptr can be used to get Status later and should be freed by
+/// StatusFreePtr. This shouldn't be used except migration purpose.
+uintptr_t StatusAllocPtr(absl::Status s);
+
+/// Frees the allocated status at ptr.
+/// This shouldn't be used except migration purpose.
+void StatusFreePtr(uintptr_t ptr);
+
+/// Get the status from ptr.
+/// This shouldn't be used except migration purpose.
+absl::Status StatusGetFromPtr(uintptr_t ptr);
+
+}  // namespace internal
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_STATUS_HELPER_H

data/src/core/lib/gprpp/sync.h

@@ -26,6 +26,9 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "absl/synchronization/mutex.h"
+#include "src/core/lib/gprpp/time_util.h"
+
 // The core library is not accessible in C++ codegen headers, and vice versa.
 // Thus, we need to have duplicate headers with similar functionality.
 // Make sure any change to this file is also reflected in
@@ -37,7 +40,23 @@
 
 namespace grpc_core {
 
-class Mutex {
+#ifdef GPR_ABSEIL_SYNC
+
+using Mutex = absl::Mutex;
+using MutexLock = absl::MutexLock;
+using ReleasableMutexLock = absl::ReleasableMutexLock;
+using CondVar = absl::CondVar;
+
+// Returns the underlying gpr_mu from Mutex. This should be used only when
+// it has to like passing the C++ mutex to C-core API.
+// TODO(veblush): Remove this after C-core no longer uses gpr_mu.
+inline gpr_mu* GetUnderlyingGprMu(Mutex* mutex) {
+  return reinterpret_cast<gpr_mu*>(mutex);
+}
+
+#else
+
+class ABSL_LOCKABLE Mutex {
  public:
   Mutex() { gpr_mu_init(&mu_); }
   ~Mutex() { gpr_mu_destroy(&mu_); }
@@ -45,52 +64,59 @@ class Mutex {
   Mutex(const Mutex&) = delete;
   Mutex& operator=(const Mutex&) = delete;
 
-  gpr_mu* get() { return &mu_; }
-  const gpr_mu* get() const { return &mu_; }
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { gpr_mu_lock(&mu_); }
+  void Unlock() ABSL_UNLOCK_FUNCTION() { gpr_mu_unlock(&mu_); }
+  bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    return gpr_mu_trylock(&mu_) != 0;
+  }
 
  private:
   gpr_mu mu_;
+
+  friend class CondVar;
+  friend gpr_mu* GetUnderlyingGprMu(Mutex* mutex);
 };
 
-// MutexLock is a std::
-class MutexLock {
+// Returns the underlying gpr_mu from Mutex. This should be used only when
+// it has to like passing the C++ mutex to C-core API.
+// TODO(veblush): Remove this after C-core no longer uses gpr_mu.
+inline gpr_mu* GetUnderlyingGprMu(Mutex* mutex) { return &mutex->mu_; }
+
+class ABSL_SCOPED_LOCKABLE MutexLock {
  public:
-  explicit MutexLock(Mutex* mu) : mu_(mu->get()) { gpr_mu_lock(mu_); }
-  explicit MutexLock(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
-  ~MutexLock() { gpr_mu_unlock(mu_); }
+  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu_->Lock();
+  }
+  ~MutexLock() ABSL_UNLOCK_FUNCTION() { mu_->Unlock(); }
 
   MutexLock(const MutexLock&) = delete;
   MutexLock& operator=(const MutexLock&) = delete;
 
  private:
-  gpr_mu* const mu_;
+  Mutex* const mu_;
 };
 
-class ReleasableMutexLock {
+class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
  public:
-  explicit ReleasableMutexLock(Mutex* mu) : mu_(mu->get()) { gpr_mu_lock(mu_); }
-  explicit ReleasableMutexLock(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
-  ~ReleasableMutexLock() {
-    if (!released_) gpr_mu_unlock(mu_);
+  explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu_->Lock();
+  }
+  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (!released_) mu_->Unlock();
   }
 
   ReleasableMutexLock(const ReleasableMutexLock&) = delete;
   ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
 
-  void Lock() {
-    GPR_DEBUG_ASSERT(released_);
-    gpr_mu_lock(mu_);
-    released_ = false;
-  }
-
-  void Unlock() {
+  void Release() ABSL_UNLOCK_FUNCTION() {
     GPR_DEBUG_ASSERT(!released_);
     released_ = true;
-    gpr_mu_unlock(mu_);
+    mu_->Unlock();
   }
 
  private:
-  gpr_mu* const mu_;
+  Mutex* const mu_;
   bool released_ = false;
 };
 
@@ -103,31 +129,94 @@ class CondVar {
   CondVar& operator=(const CondVar&) = delete;
 
   void Signal() { gpr_cv_signal(&cv_); }
-  void Broadcast() { gpr_cv_broadcast(&cv_); }
+  void SignalAll() { gpr_cv_broadcast(&cv_); }
+
+  void Wait(Mutex* mu) { WaitWithDeadline(mu, absl::InfiniteFuture()); }
+  bool WaitWithTimeout(Mutex* mu, absl::Duration timeout) {
+    return gpr_cv_wait(&cv_, &mu->mu_, ToGprTimeSpec(timeout)) != 0;
+  }
+  bool WaitWithDeadline(Mutex* mu, absl::Time deadline) {
+    return gpr_cv_wait(&cv_, &mu->mu_, ToGprTimeSpec(deadline)) != 0;
+  }
+
+ private:
+  gpr_cv cv_;
+};
+
+#endif  // GPR_ABSEIL_SYNC
+
+template <typename Predicate>
+static void WaitUntil(CondVar* cv, Mutex* mu, Predicate pred) {
+  while (!pred()) {
+    cv->Wait(mu);
+  }
+}
+
+// Returns true iff we timed-out
+template <typename Predicate>
+static bool WaitUntilWithTimeout(CondVar* cv, Mutex* mu, Predicate pred,
+                                 absl::Duration timeout) {
+  while (!pred()) {
+    if (cv->WaitWithTimeout(mu, timeout)) return true;
+  }
+  return false;
+}
+
+// Returns true iff we timed-out
+template <typename Predicate>
+static bool WaitUntilWithDeadline(CondVar* cv, Mutex* mu, Predicate pred,
+                                  absl::Time deadline) {
+  while (!pred()) {
+    if (cv->WaitWithDeadline(mu, deadline)) return true;
+  }
+  return false;
+}
+
+// Deprecated. Prefer MutexLock
+class MutexLockForGprMu {
+ public:
+  explicit MutexLockForGprMu(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
+  ~MutexLockForGprMu() { gpr_mu_unlock(mu_); }
+
+  MutexLockForGprMu(const MutexLock&) = delete;
+  MutexLockForGprMu& operator=(const MutexLock&) = delete;
+
+ private:
+  gpr_mu* const mu_;
+};
 
-  int Wait(Mutex* mu) { return Wait(mu, gpr_inf_future(GPR_CLOCK_REALTIME)); }
-  int Wait(Mutex* mu, const gpr_timespec& deadline) {
-    return gpr_cv_wait(&cv_, mu->get(), deadline);
+// Deprecated. Prefer MutexLock or ReleasableMutexLock
+class ABSL_SCOPED_LOCKABLE LockableAndReleasableMutexLock {
+ public:
+  explicit LockableAndReleasableMutexLock(Mutex* mu)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu_->Lock();
   }
+  ~LockableAndReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (!released_) mu_->Unlock();
+  }
+
+  LockableAndReleasableMutexLock(const LockableAndReleasableMutexLock&) =
+      delete;
+  LockableAndReleasableMutexLock& operator=(
+      const LockableAndReleasableMutexLock&) = delete;
 
-  template <typename Predicate>
-  void WaitUntil(Mutex* mu, Predicate pred) {
-    while (!pred()) {
-      Wait(mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-    }
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    GPR_DEBUG_ASSERT(released_);
+    mu_->Lock();
+    released_ = false;
   }
 
-  // Returns true iff we timed-out
-  template <typename Predicate>
-  bool WaitUntil(Mutex* mu, Predicate pred, const gpr_timespec& deadline) {
-    while (!pred()) {
-      if (Wait(mu, deadline)) return true;
-    }
-    return false;
+  void Release() ABSL_UNLOCK_FUNCTION() {
+    GPR_DEBUG_ASSERT(!released_);
+    released_ = true;
+    mu_->Unlock();
   }
 
  private:
-  gpr_cv cv_;
+  Mutex* const mu_;
+  bool released_ = false;
 };
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/thd.h

@@ -157,7 +157,7 @@ class Thread {
   Thread& operator=(const Thread&) = delete;
 
   /// The thread states are as follows:
-  /// FAKE -- just a dummy placeholder Thread created by the default constructor
+  /// FAKE -- just a phony placeholder Thread created by the default constructor
   /// ALIVE -- an actual thread of control exists associated with this thread
   /// STARTED -- the thread of control has been started
   /// DONE -- the thread of control has completed and been joined

data/src/core/lib/gprpp/time_util.cc

@@ -0,0 +1,77 @@
+//
+// Copyright 2021 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/time_util.h"
+
+namespace grpc_core {
+
+gpr_timespec ToGprTimeSpec(absl::Duration duration) {
+  if (duration == absl::InfiniteDuration()) {
+    return gpr_inf_future(GPR_TIMESPAN);
+  } else if (duration == -absl::InfiniteDuration()) {
+    return gpr_inf_past(GPR_TIMESPAN);
+  } else {
+    int64_t s = absl::IDivDuration(duration, absl::Seconds(1), &duration);
+    int64_t n = absl::IDivDuration(duration, absl::Nanoseconds(1), &duration);
+    return gpr_time_add(gpr_time_from_seconds(s, GPR_TIMESPAN),
+                        gpr_time_from_nanos(n, GPR_TIMESPAN));
+  }
+}
+
+gpr_timespec ToGprTimeSpec(absl::Time time) {
+  if (time == absl::InfiniteFuture()) {
+    return gpr_inf_future(GPR_CLOCK_REALTIME);
+  } else if (time == absl::InfinitePast()) {
+    return gpr_inf_past(GPR_CLOCK_REALTIME);
+  } else {
+    timespec ts = absl::ToTimespec(time);
+    gpr_timespec out;
+    out.tv_sec = static_cast<decltype(out.tv_sec)>(ts.tv_sec);
+    out.tv_nsec = static_cast<decltype(out.tv_nsec)>(ts.tv_nsec);
+    out.clock_type = GPR_CLOCK_REALTIME;
+    return out;
+  }
+}
+
+absl::Duration ToAbslDuration(gpr_timespec ts) {
+  GPR_ASSERT(ts.clock_type == GPR_TIMESPAN);
+  if (gpr_time_cmp(ts, gpr_inf_future(GPR_TIMESPAN)) == 0) {
+    return absl::InfiniteDuration();
+  } else if (gpr_time_cmp(ts, gpr_inf_past(GPR_TIMESPAN)) == 0) {
+    return -absl::InfiniteDuration();
+  } else {
+    return absl::Seconds(ts.tv_sec) + absl::Nanoseconds(ts.tv_nsec);
+  }
+}
+
+absl::Time ToAbslTime(gpr_timespec ts) {
+  GPR_ASSERT(ts.clock_type != GPR_TIMESPAN);
+  gpr_timespec rts = gpr_convert_clock_type(ts, GPR_CLOCK_REALTIME);
+  if (gpr_time_cmp(rts, gpr_inf_future(GPR_CLOCK_REALTIME)) == 0) {
+    return absl::InfiniteFuture();
+  } else if (gpr_time_cmp(rts, gpr_inf_past(GPR_CLOCK_REALTIME)) == 0) {
+    return absl::InfinitePast();
+  } else {
+    return absl::UnixEpoch() + absl::Seconds(rts.tv_sec) +
+           absl::Nanoseconds(rts.tv_nsec);
+  }
+}
+
+}  // namespace grpc_core