grpc 1.33.0.pre1 → 1.34.0

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

@@ -29,7 +29,6 @@
 #include <cassert>
 #include <cinttypes>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -51,21 +50,19 @@ class RefCount {
 
   // `init` is the initial refcount stored in this object.
   //
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
-  constexpr explicit RefCount(
+  // `trace` is a string to be logged with trace events; if null, no
+  // trace logging will be done.  Tracing is a no-op in non-debug builds.
+  explicit RefCount(
       Value init = 1,
-      TraceFlagT*
+      const char*
 #ifndef NDEBUG
           // Leave unnamed if NDEBUG to avoid unused parameter warning
-          trace_flag
+          trace
 #endif
       = nullptr)
       :
 #ifndef NDEBUG
-        trace_flag_(trace_flag),
+        trace_(trace),
 #endif
         value_(init) {
   }
@@ -74,9 +71,9 @@ class RefCount {
   void Ref(Value n = 1) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(n, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + n);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
+              prior, prior + n);
     }
 #else
     value_.FetchAdd(n, MemoryOrder::RELAXED);
@@ -85,16 +82,15 @@ class RefCount {
   void Ref(const DebugLocation& location, const char* reason, Value n = 1) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(n, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + n, reason);
+              trace_, this, location.file(), location.line(), prior, prior + n,
+              reason);
     }
 #else
     // Use conditionally-important parameters
     (void)location;
     (void)reason;
-
     value_.FetchAdd(n, MemoryOrder::RELAXED);
 #endif
   }
@@ -103,9 +99,9 @@ class RefCount {
   void RefNonZero() {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + 1);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
+              prior, prior + 1);
     }
     assert(prior > 0);
 #else
@@ -115,10 +111,10 @@ class RefCount {
   void RefNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + 1, reason);
+              trace_, this, location.file(), location.line(), prior, prior + 1,
+              reason);
     }
     assert(prior > 0);
 #else
@@ -131,23 +127,22 @@ class RefCount {
 
   bool RefIfNonZero() {
 #ifndef NDEBUG
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       const Value prior = get();
       gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + 1);
+              trace_, this, prior, prior + 1);
     }
 #endif
     return value_.IncrementIfNonzero();
   }
   bool RefIfNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       const Value prior = get();
       gpr_log(GPR_INFO,
-              "%s:%p %s:%d ref_if_non_zero "
-              "%" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + 1, reason);
+              "%s:%p %s:%d ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR " %s",
+              trace_, this, location.file(), location.line(), prior, prior + 1,
+              reason);
     }
 #endif
     // Avoid unused-parameter warnings for debug-only parameters
@@ -160,14 +155,15 @@ class RefCount {
   bool Unref() {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    auto* trace = trace_;
 #endif
     const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
 #ifndef NDEBUG
-    if (trace_flag != nullptr && trace_flag->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p unref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag->name(), this, prior, prior - 1);
+    if (trace != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p unref %" PRIdPTR " -> %" PRIdPTR, trace, this,
+              prior, prior - 1);
     }
     GPR_DEBUG_ASSERT(prior > 0);
 #endif
@@ -176,15 +172,16 @@ class RefCount {
   bool Unref(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    auto* trace = trace_;
 #endif
     const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
 #ifndef NDEBUG
-    if (trace_flag != nullptr && trace_flag->enabled()) {
+    if (trace != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d unref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag->name(), this, location.file(), location.line(), prior,
-              prior - 1, reason);
+              trace, this, location.file(), location.line(), prior, prior - 1,
+              reason);
     }
     GPR_DEBUG_ASSERT(prior > 0);
 #else
@@ -199,7 +196,7 @@ class RefCount {
   Value get() const { return value_.Load(MemoryOrder::RELAXED); }
 
 #ifndef NDEBUG
-  TraceFlag* trace_flag_;
+  const char* trace_;
 #endif
   Atomic<Value> value_;
 };
@@ -315,13 +312,10 @@ class RefCounted : public Impl {
   RefCounted& operator=(const RefCounted&) = delete;
 
  protected:
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
-  explicit RefCounted(TraceFlagT* trace_flag = nullptr,
+  // Note: Tracing is a no-op on non-debug builds.
+  explicit RefCounted(const char* trace = nullptr,
                       intptr_t initial_refcount = 1)
-      : refs_(initial_refcount, trace_flag) {}
+      : refs_(initial_refcount, trace) {}
 
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().

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

@@ -39,29 +39,27 @@ class RefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   template <typename Y>
-  explicit RefCountedPtr(Y* value) {
-    value_ = value;
-  }
+  RefCountedPtr(Y* value) : value_(value) {}
 
   // Move ctors.
-  RefCountedPtr(RefCountedPtr&& other) {
+  RefCountedPtr(RefCountedPtr&& other) noexcept {
     value_ = other.value_;
     other.value_ = nullptr;
   }
   template <typename Y>
-  RefCountedPtr(RefCountedPtr<Y>&& other) {
+  RefCountedPtr(RefCountedPtr<Y>&& other) noexcept {
     value_ = static_cast<T*>(other.value_);
     other.value_ = nullptr;
   }
 
   // Move assignment.
-  RefCountedPtr& operator=(RefCountedPtr&& other) {
+  RefCountedPtr& operator=(RefCountedPtr&& other) noexcept {
     reset(other.value_);
     other.value_ = nullptr;
     return *this;
   }
   template <typename Y>
-  RefCountedPtr& operator=(RefCountedPtr<Y>&& other) {
+  RefCountedPtr& operator=(RefCountedPtr<Y>&& other) noexcept {
     reset(other.value_);
     other.value_ = nullptr;
     return *this;
@@ -192,24 +190,24 @@ class WeakRefCountedPtr {
   }
 
   // Move ctors.
-  WeakRefCountedPtr(WeakRefCountedPtr&& other) {
+  WeakRefCountedPtr(WeakRefCountedPtr&& other) noexcept {
     value_ = other.value_;
     other.value_ = nullptr;
   }
   template <typename Y>
-  WeakRefCountedPtr(WeakRefCountedPtr<Y>&& other) {
+  WeakRefCountedPtr(WeakRefCountedPtr<Y>&& other) noexcept {
     value_ = static_cast<T*>(other.value_);
     other.value_ = nullptr;
   }
 
   // Move assignment.
-  WeakRefCountedPtr& operator=(WeakRefCountedPtr&& other) {
+  WeakRefCountedPtr& operator=(WeakRefCountedPtr&& other) noexcept {
     reset(other.value_);
     other.value_ = nullptr;
     return *this;
   }
   template <typename Y>
-  WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) {
+  WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) noexcept {
     reset(other.value_);
     other.value_ = nullptr;
     return *this;

data/src/core/lib/{security/authorization/mock_cel/statusor.h → gprpp/stat.h}

@@ -1,3 +1,4 @@
+//
 // Copyright 2020 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -11,40 +12,27 @@
 // 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_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H
+#ifndef GRPC_CORE_LIB_GPRPP_STAT_H
+#define GRPC_CORE_LIB_GPRPP_STAT_H
 
 #include <grpc/support/port_platform.h>
 
-#include <memory>
+#include <stdio.h>
+#include <time.h>
 
 #include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
-
-template <typename T>
-class StatusOr {
- public:
-  StatusOr() = default;
-
-  StatusOr(const T& value) {}
-
-  StatusOr(const absl::Status& status) {}
-
-  StatusOr(absl::Status&& status) {}
 
-  bool ok() const { return true; }
-};
+// Gets the last-modified timestamp of a file or a directory.
+// On success, the correct timestamp will be filled with an StatusCode::kOk
+// returned. Otherwise, timestamp will be untouched and an
+// StatusCode::kInternal will be returned.
+absl::Status GetFileModificationTime(const char* filename, time_t* timestamp);
 
-}  // namespace mock_cel
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H
+#endif  // GRPC_CORE_LIB_GPRPP_STAT_H

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

@@ -0,0 +1,49 @@
+//
+// Copyright 2020 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>
+
+#ifdef GPR_POSIX_STAT
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/stat.h"
+
+namespace grpc_core {
+
+absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
+  GPR_ASSERT(filename != nullptr);
+  GPR_ASSERT(timestamp != nullptr);
+  struct stat buf;
+  if (stat(filename, &buf) != 0) {
+    const char* error_msg = strerror(errno);
+    gpr_log(GPR_ERROR, "stat failed for filename %s with error %s.", filename,
+            error_msg);
+    return absl::Status(absl::StatusCode::kInternal, error_msg);
+  }
+  // Last file/directory modification time.
+  *timestamp = buf.st_mtime;
+  return absl::OkStatus();
+}
+
+}  // namespace grpc_core
+
+#endif  // GPR_POSIX_STAT

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

@@ -0,0 +1,48 @@
+//
+// Copyright 2020 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>
+
+#ifdef GPR_WINDOWS_STAT
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/stat.h"
+
+namespace grpc_core {
+
+absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
+  GPR_ASSERT(filename != nullptr);
+  GPR_ASSERT(timestamp != nullptr);
+  struct _stat buf;
+  if (_stat(filename, &buf) != 0) {
+    const char* error_msg = strerror(errno);
+    gpr_log(GPR_ERROR, "_stat failed for filename %s with error %s.", filename,
+            error_msg);
+    return absl::Status(absl::StatusCode::kInternal, error_msg);
+  }
+  // Last file/directory modification time.
+  *timestamp = buf.st_mtime;
+  return absl::OkStatus();
+}
+
+}  // namespace grpc_core
+
+#endif  // GPR_WINDOWS_STAT

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

@@ -91,7 +91,7 @@ class Thread {
 
   /// Move constructor for thread. After this is called, the other thread
   /// no longer represents a living thread object
-  Thread(Thread&& other)
+  Thread(Thread&& other) noexcept
       : state_(other.state_), impl_(other.impl_), options_(other.options_) {
     other.state_ = MOVED;
     other.impl_ = nullptr;
@@ -101,7 +101,7 @@ class Thread {
   /// Move assignment operator for thread. After this is called, the other
   /// thread no longer represents a living thread object. Not allowed if this
   /// thread actually exists
-  Thread& operator=(Thread&& other) {
+  Thread& operator=(Thread&& other) noexcept {
     if (this != &other) {
       // TODO(vjpai): if we can be sure that all Thread's are actually
       // constructed, then we should assert GPR_ASSERT(impl_ == nullptr) here.

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

@@ -105,45 +105,45 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
       GPR_ASSERT(pthread_attr_setstacksize(&attr, stack_size) == 0);
     }
 
-    *success =
-        (pthread_create(&pthread_id_, &attr,
-                        [](void* v) -> void* {
-                          thd_arg arg = *static_cast<thd_arg*>(v);
-                          free(v);
-                          if (arg.name != nullptr) {
+    *success = (pthread_create(
+                    &pthread_id_, &attr,
+                    [](void* v) -> void* {
+                      thd_arg arg = *static_cast<thd_arg*>(v);
+                      free(v);
+                      if (arg.name != nullptr) {
 #if GPR_APPLE_PTHREAD_NAME
-                            /* Apple supports 64 characters, and will
-                             * truncate if it's longer. */
-                            pthread_setname_np(arg.name);
+                        /* Apple supports 64 characters, and will
+                         * truncate if it's longer. */
+                        pthread_setname_np(arg.name);
 #elif GPR_LINUX_PTHREAD_NAME
-                            /* Linux supports 16 characters max, and will
-                             * error if it's longer. */
-                            char buf[16];
-                            size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
-                            strncpy(buf, arg.name, buf_len);
-                            buf[buf_len] = '\0';
-                            pthread_setname_np(pthread_self(), buf);
+                        /* Linux supports 16 characters max, and will
+                         * error if it's longer. */
+                        char buf[16];
+                        size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
+                        strncpy(buf, arg.name, buf_len);
+                        buf[buf_len] = '\0';
+                        pthread_setname_np(pthread_self(), buf);
 #endif  // GPR_APPLE_PTHREAD_NAME
-                          }
-
-                          gpr_mu_lock(&arg.thread->mu_);
-                          while (!arg.thread->started_) {
-                            gpr_cv_wait(&arg.thread->ready_, &arg.thread->mu_,
-                                        gpr_inf_future(GPR_CLOCK_MONOTONIC));
-                          }
-                          gpr_mu_unlock(&arg.thread->mu_);
-
-                          if (!arg.joinable) {
-                            delete arg.thread;
-                          }
-
-                          (*arg.body)(arg.arg);
-                          if (arg.tracked) {
-                            Fork::DecThreadCount();
-                          }
-                          return nullptr;
-                        },
-                        info) == 0);
+                      }
+
+                      gpr_mu_lock(&arg.thread->mu_);
+                      while (!arg.thread->started_) {
+                        gpr_cv_wait(&arg.thread->ready_, &arg.thread->mu_,
+                                    gpr_inf_future(GPR_CLOCK_MONOTONIC));
+                      }
+                      gpr_mu_unlock(&arg.thread->mu_);
+
+                      if (!arg.joinable) {
+                        delete arg.thread;
+                      }
+
+                      (*arg.body)(arg.arg);
+                      if (arg.tracked) {
+                        Fork::DecThreadCount();
+                      }
+                      return nullptr;
+                    },
+                    info) == 0);
 
     GPR_ASSERT(pthread_attr_destroy(&attr) == 0);