grpc 1.48.0 → 1.50.0

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

@@ -23,11 +23,14 @@
 #include <ostream>
 #include <string>
 
+#include "absl/types/optional.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
 
 namespace grpc_core {
@@ -61,6 +64,35 @@ class Duration;
 // Timestamp represents a discrete point in time.
 class Timestamp {
  public:
+  // Base interface for time providers.
+  class Source {
+   public:
+    // Return the current time.
+    virtual Timestamp Now() = 0;
+    virtual void InvalidateCache() {}
+
+   protected:
+    // We don't delete through this interface, so non-virtual dtor is fine.
+    ~Source() = default;
+  };
+
+  class ScopedSource : public Source {
+   public:
+    ScopedSource() : previous_(thread_local_time_source_) {
+      thread_local_time_source_ = this;
+    }
+    ScopedSource(const ScopedSource&) = delete;
+    ScopedSource& operator=(const ScopedSource&) = delete;
+    void InvalidateCache() override { previous_->InvalidateCache(); }
+
+   protected:
+    ~ScopedSource() { thread_local_time_source_ = previous_; }
+    Source* previous() const { return previous_; }
+
+   private:
+    Source* const previous_;
+  };
+
   constexpr Timestamp() = default;
   // Constructs a Timestamp from a gpr_timespec.
   static Timestamp FromTimespecRoundDown(gpr_timespec t);
@@ -70,6 +102,8 @@ class Timestamp {
   static Timestamp FromCycleCounterRoundUp(gpr_cycle_counter c);
   static Timestamp FromCycleCounterRoundDown(gpr_cycle_counter c);
 
+  static Timestamp Now() { return thread_local_time_source_->Now(); }
+
   static constexpr Timestamp FromMillisecondsAfterProcessEpoch(int64_t millis) {
     return Timestamp(millis);
   }
@@ -116,6 +150,21 @@ class Timestamp {
   explicit constexpr Timestamp(int64_t millis) : millis_(millis) {}
 
   int64_t millis_ = 0;
+  static GPR_THREAD_LOCAL(Timestamp::Source*) thread_local_time_source_;
+};
+
+class ScopedTimeCache final : public Timestamp::ScopedSource {
+ public:
+  Timestamp Now() override;
+
+  void InvalidateCache() override {
+    cached_time_ = absl::nullopt;
+    Timestamp::ScopedSource::InvalidateCache();
+  }
+  void TestOnlySetNow(Timestamp now) { cached_time_ = now; }
+
+ private:
+  absl::optional<Timestamp> cached_time_;
 };
 
 // Duration represents a span of time.
@@ -200,6 +249,7 @@ class Duration {
     }
     return *this;
   }
+  Duration& operator*=(double multiplier);
   Duration& operator+=(Duration other) {
     millis_ += other.millis_;
     return *this;
@@ -287,6 +337,11 @@ inline Duration Duration::FromSecondsAsDouble(double seconds) {
   return Milliseconds(static_cast<int64_t>(millis));
 }
 
+inline Duration& Duration::operator*=(double multiplier) {
+  *this = *this * multiplier;
+  return *this;
+}
+
 inline Timestamp& Timestamp::operator+=(Duration duration) {
   return *this = (*this + duration);
 }

data/src/core/lib/{event_engine/iomgr_engine → gprpp}/time_averaged_stats.cc

@@ -18,10 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/iomgr_engine/time_averaged_stats.h"
+#include "src/core/lib/gprpp/time_averaged_stats.h"
 
-namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace grpc_core {
 
 TimeAveragedStats::TimeAveragedStats(double init_avg, double regress_weight,
                                      double persistence_factor)
@@ -58,5 +57,4 @@ double TimeAveragedStats::UpdateAverage() {
   return aggregate_weighted_avg_;
 }
 
-}  // namespace iomgr_engine
-}  // namespace grpc_event_engine
+}  // namespace grpc_core

data/src/core/lib/{event_engine/iomgr_engine → gprpp}/time_averaged_stats.h

@@ -16,11 +16,10 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H
+#ifndef GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
+#define GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
 
-namespace grpc_event_engine {
-namespace iomgr_engine {
+namespace grpc_core {
 
 /* This tracks a time-decaying weighted average.  It works by collecting
    batches of samples and then mixing their average into a time-decaying
@@ -75,7 +74,6 @@ class TimeAveragedStats {
   double aggregate_weighted_avg_ = init_avg_;
 };
 
-}  // namespace iomgr_engine
-}  // namespace grpc_event_engine
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIME_AVERAGED_STATS_H */
+#endif /* GRPC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H */

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

@@ -0,0 +1,61 @@
+// 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>
+
+#include "src/core/lib/gprpp/validation_errors.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/strip.h"
+
+namespace grpc_core {
+
+void ValidationErrors::PushField(absl::string_view ext) {
+  // Skip leading '.' for top-level field names.
+  if (fields_.empty()) absl::ConsumePrefix(&ext, ".");
+  fields_.emplace_back(std::string(ext));
+}
+
+void ValidationErrors::PopField() { fields_.pop_back(); }
+
+void ValidationErrors::AddError(absl::string_view error) {
+  field_errors_[absl::StrJoin(fields_, "")].emplace_back(error);
+}
+
+bool ValidationErrors::FieldHasErrors() const {
+  return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
+}
+
+absl::Status ValidationErrors::status(absl::string_view prefix) const {
+  if (field_errors_.empty()) return absl::OkStatus();
+  std::vector<std::string> errors;
+  for (const auto& p : field_errors_) {
+    if (p.second.size() > 1) {
+      errors.emplace_back(absl::StrCat("field:", p.first, " errors:[",
+                                       absl::StrJoin(p.second, "; "), "]"));
+    } else {
+      errors.emplace_back(
+          absl::StrCat("field:", p.first, " error:", p.second[0]));
+    }
+  }
+  return absl::InvalidArgumentError(
+      absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]"));
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,110 @@
+// 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.
+
+#ifndef GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
+#define GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// Tracks errors that occur during validation of a data structure (e.g.,
+// a JSON object or protobuf message).  Errors are tracked based on
+// which field they are associated with.  If at least one error occurs
+// during validation, the validation failed.
+//
+// Example usage:
+//
+// absl::StatusOr<std::string> GetFooBar(const Json::Object& json) {
+//   ValidationErrors errors;
+//   {
+//     ValidationErrors::ScopedField field("foo");
+//     auto it = json.object_value().find("foo");
+//     if (it == json.object_value().end()) {
+//       errors.AddError("field not present");
+//     } else if (it->second.type() != Json::Type::OBJECT) {
+//       errors.AddError("must be a JSON object");
+//     } else {
+//       const Json& foo = it->second;
+//       ValidationErrors::ScopedField field(".bar");
+//       auto it = foo.object_value().find("bar");
+//       if (it == json.object_value().end()) {
+//         errors.AddError("field not present");
+//       } else if (it->second.type() != Json::Type::STRING) {
+//         errors.AddError("must be a JSON string");
+//       } else {
+//         return it->second.string_value();
+//       }
+//     }
+//   }
+//   return errors.status("errors validating foo.bar");
+// }
+class ValidationErrors {
+ public:
+  // Pushes a field name onto the stack at construction and pops it off
+  // of the stack at destruction.
+  class ScopedField {
+   public:
+    ScopedField(ValidationErrors* errors, absl::string_view field_name)
+        : errors_(errors) {
+      errors_->PushField(field_name);
+    }
+    ~ScopedField() { errors_->PopField(); }
+
+   private:
+    ValidationErrors* errors_;
+  };
+
+  // Records that we've encountered an error associated with the current
+  // field.
+  void AddError(absl::string_view error) GPR_ATTRIBUTE_NOINLINE;
+
+  // Returns true if the current field has errors.
+  bool FieldHasErrors() const GPR_ATTRIBUTE_NOINLINE;
+
+  // Returns the resulting status of parsing.
+  absl::Status status(absl::string_view prefix) const;
+
+  // Returns true if there are no errors.
+  bool ok() const { return field_errors_.empty(); }
+
+  size_t size() const { return field_errors_.size(); }
+
+ private:
+  // Pushes a field name onto the stack.
+  void PushField(absl::string_view ext) GPR_ATTRIBUTE_NOINLINE;
+  // Pops a field name off of the stack.
+  void PopField() GPR_ATTRIBUTE_NOINLINE;
+
+  // Errors that we have encountered so far, keyed by field name.
+  // TODO(roth): If we don't actually have any fields for which we
+  // report more than one error, simplify this data structure.
+  std::map<std::string /*field_name*/, std::vector<std::string>> field_errors_;
+  // Stack of field names indicating the field that we are currently
+  // validating.
+  std::vector<std::string> fields_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H

data/src/core/lib/{iomgr → gprpp}/work_serializer.cc

@@ -1,29 +1,45 @@
-/*
- *
- * Copyright 2019 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.
- *
- */
+//
+// Copyright 2019 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/iomgr/work_serializer.h"
+#include "src/core/lib/gprpp/work_serializer.h"
+
+#include <stdint.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <utility>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/mpscq.h"
+#include "src/core/lib/gprpp/orphanable.h"
 
 namespace grpc_core {
 
 DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer");
 
+//
+// WorkSerializer::WorkSerializerImpl
+//
+
 class WorkSerializer::WorkSerializerImpl : public Orphanable {
  public:
   void Run(std::function<void()> callback, const DebugLocation& location);

data/src/core/lib/{iomgr → gprpp}/work_serializer.h

@@ -1,36 +1,30 @@
-/*
- *
- * Copyright 2019 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.
- *
- */
+//
+// Copyright 2019 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_WORK_SERIALIZER_H
+#define GRPC_CORE_LIB_GPRPP_WORK_SERIALIZER_H
 
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
 #include <functional>
 
-#include "absl/synchronization/mutex.h"
+#include "absl/base/thread_annotations.h"
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
 
@@ -87,6 +81,6 @@ class ABSL_LOCKABLE WorkSerializer {
   OrphanablePtr<WorkSerializerImpl> impl_;
 };
 
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H */
+#endif  // GRPC_CORE_LIB_GPRPP_WORK_SERIALIZER_H

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

@@ -16,13 +16,17 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H
+#ifndef GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
+#define GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <string>
 
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
@@ -32,23 +36,18 @@ class ProxyMapperInterface {
   virtual ~ProxyMapperInterface() = default;
 
   /// Determines the proxy name to resolve for \a server_uri.
-  /// If no proxy is needed, returns false.
-  /// Otherwise, sets \a name_to_resolve, optionally sets \a new_args,
-  /// and returns true.
-  virtual bool MapName(const char* server_uri, const grpc_channel_args* args,
-                       char** name_to_resolve,
-                       grpc_channel_args** new_args) = 0;
+  /// If no proxy is needed, returns nullopt.
+  /// Otherwise, updates \a args and returns the name to resolve.
+  virtual absl::optional<std::string> MapName(absl::string_view server_uri,
+                                              ChannelArgs* args) = 0;
 
   /// Determines the proxy address to use to contact \a address.
-  /// If no proxy is needed, returns false.
-  /// Otherwise, sets \a new_address, optionally sets \a new_args, and
-  /// returns true.
-  virtual bool MapAddress(const grpc_resolved_address& address,
-                          const grpc_channel_args* args,
-                          grpc_resolved_address** new_address,
-                          grpc_channel_args** new_args) = 0;
+  /// If no proxy is needed, returns nullopt.
+  /// Otherwise, updates \a args, and returns a new address.
+  virtual absl::optional<grpc_resolved_address> MapAddress(
+      const grpc_resolved_address& address, ChannelArgs* args) = 0;
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H */
+#endif /* GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H */

data/src/core/lib/handshaker/proxy_mapper_registry.cc

@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2017 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/handshaker/proxy_mapper_registry.h"
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+void ProxyMapperRegistry::Builder::Register(
+    bool at_start, std::unique_ptr<ProxyMapperInterface> mapper) {
+  if (at_start) {
+    mappers_.insert(mappers_.begin(), std::move(mapper));
+  } else {
+    mappers_.emplace_back(std::move(mapper));
+  }
+}
+
+ProxyMapperRegistry ProxyMapperRegistry::Builder::Build() {
+  ProxyMapperRegistry registry;
+  registry.mappers_ = std::move(mappers_);
+  return registry;
+}
+
+absl::optional<std::string> ProxyMapperRegistry::MapName(
+    absl::string_view server_uri, ChannelArgs* args) const {
+  ChannelArgs args_backup = *args;
+  for (const auto& mapper : mappers_) {
+    *args = args_backup;
+    auto r = mapper->MapName(server_uri, args);
+    if (r.has_value()) return r;
+  }
+  *args = args_backup;
+  return absl::nullopt;
+}
+
+absl::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
+    const grpc_resolved_address& address, ChannelArgs* args) const {
+  ChannelArgs args_backup = *args;
+  for (const auto& mapper : mappers_) {
+    *args = args_backup;
+    auto r = mapper->MapAddress(address, args);
+    if (r.has_value()) return r;
+  }
+  *args = args_backup;
+  return absl::nullopt;
+}
+
+}  // namespace grpc_core

data/src/core/lib/handshaker/proxy_mapper_registry.h

@@ -0,0 +1,75 @@
+/*
+ *
+ * Copyright 2017 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_HANDSHAKER_PROXY_MAPPER_REGISTRY_H
+#define GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/handshaker/proxy_mapper.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+
+namespace grpc_core {
+
+class ProxyMapperRegistry {
+  using ProxyMapperList = std::vector<std::unique_ptr<ProxyMapperInterface>>;
+
+ public:
+  class Builder {
+   public:
+    /// Registers a new proxy mapper.
+    /// If \a at_start is true, the new mapper will be at the beginning of
+    /// the list.  Otherwise, it will be added to the end.
+    void Register(bool at_start, std::unique_ptr<ProxyMapperInterface> mapper);
+
+    ProxyMapperRegistry Build();
+
+   private:
+    ProxyMapperList mappers_;
+  };
+
+  ~ProxyMapperRegistry() = default;
+  ProxyMapperRegistry(const ProxyMapperRegistry&) = delete;
+  ProxyMapperRegistry& operator=(const ProxyMapperRegistry&) = delete;
+  ProxyMapperRegistry(ProxyMapperRegistry&&) = default;
+  ProxyMapperRegistry& operator=(ProxyMapperRegistry&&) = default;
+
+  absl::optional<std::string> MapName(absl::string_view server_uri,
+                                      ChannelArgs* args) const;
+
+  absl::optional<grpc_resolved_address> MapAddress(
+      const grpc_resolved_address& address, ChannelArgs* args) const;
+
+ private:
+  ProxyMapperRegistry() = default;
+
+  ProxyMapperList mappers_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_REGISTRY_H */