grpc 1.46.3 → 1.53.1

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

@@ -0,0 +1,79 @@
+//
+//
+// 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_SRC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
+#define GRPC_SRC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H
+
+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
+// weighted mean.  It is designed for batch operations where we do many adds
+// before updating the average.
+
+class TimeAveragedStats {
+ public:
+  TimeAveragedStats(double init_avg, double regress_weight,
+                    double persistence_factor);
+
+  // Add a sample to the current batch.
+  void AddSample(double value);
+  // Complete a batch and compute the new estimate of the average sample
+  // value.
+  double UpdateAverage();
+
+  double aggregate_weighted_avg() const { return aggregate_weighted_avg_; }
+  double aggregate_total_weight() const { return aggregate_total_weight_; }
+
+ private:
+  // The initial average value.  This is the reported average until the first
+  // grpc_time_averaged_stats_update_average call.  If a positive regress_weight
+  // is used, we also regress towards this value on each update.
+  const double init_avg_;
+  // The sample weight of "init_avg" that is mixed in with each call to
+  // grpc_time_averaged_stats_update_average.  If the calls to
+  // grpc_time_averaged_stats_add_sample stop, this will cause the average to
+  // regress back to the mean.  This should be non-negative.  Set it to 0 to
+  // disable the bias.  A value of 1 has the effect of adding in 1 bonus sample
+  // with value init_avg to each sample period.
+  const double regress_weight_;
+  // This determines the rate of decay of the time-averaging from one period
+  // to the next by scaling the aggregate_total_weight of samples from prior
+  // periods when combining with the latest period.  It should be in the range
+  // [0,1].  A higher value adapts more slowly.  With a value of 0.5, if the
+  // batches each have k samples, the samples_in_avg_ will grow to 2 k, so the
+  // weighting of the time average will eventually be 1/3 new batch and 2/3
+  // old average.
+  const double persistence_factor_;
+
+  // The total value of samples since the last UpdateAverage().
+  double batch_total_value_ = 0;
+  // The number of samples since the last UpdateAverage().
+  double batch_num_samples_ = 0;
+  // The time-decayed sum of batch_num_samples_ over previous batches.  This is
+  // the "weight" of the old aggregate_weighted_avg_ when updating the
+  // average.
+  double aggregate_total_weight_ = 0;
+  // A time-decayed average of the (batch_total_value_ / batch_num_samples_),
+  // computed by decaying the samples_in_avg_ weight in the weighted average.
+  double aggregate_weighted_avg_ = init_avg_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_TIME_AVERAGED_STATS_H

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

@@ -18,7 +18,11 @@
 
 #include "src/core/lib/gprpp/time_util.h"
 
+#include <stdint.h>
+#include <time.h>
+
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 namespace grpc_core {
 

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_GPRPP_TIME_UTIL_H
-#define GRPC_CORE_LIB_GPRPP_TIME_UTIL_H
+#ifndef GRPC_SRC_CORE_LIB_GPRPP_TIME_UTIL_H
+#define GRPC_SRC_CORE_LIB_GPRPP_TIME_UTIL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -39,4 +39,4 @@ absl::Time ToAbslTime(gpr_timespec ts);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_GPRPP_TIME_UTIL_H
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_TIME_UTIL_H

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

@@ -0,0 +1,104 @@
+//
+// 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_SRC_CORE_LIB_GPRPP_UNIQUE_TYPE_NAME_H
+#define GRPC_SRC_CORE_LIB_GPRPP_UNIQUE_TYPE_NAME_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/gpr/useful.h"
+
+// Provides a type name that is unique by instance rather than by
+// string content.  This is useful in cases where there are different
+// implementations of a given interface that need to be differentiated from
+// each other for down-casting purposes, where it is undesirable to provide
+// a registry to avoid name collisions.
+//
+// Expected usage:
+//
+//// Interface has a virtual method that returns a UniqueTypeName.
+// class Interface {
+// public:
+// virtual ~Interface() = default;
+// virtual UniqueTypeName type() const = 0;
+// };
+
+//// Implementation uses a static factory instance to return the same
+//// UniqueTypeName for every instance.
+// class FooImplementation : public Interface {
+// public:
+// UniqueTypeName type() const override {
+//   static UniqueTypeName::Factory kFactory("Foo");
+//   return kFactory.Create();
+// }
+// };
+//
+
+namespace grpc_core {
+
+class UniqueTypeName {
+ public:
+  // Factory class.  There should be a single static instance of this
+  // for each unique type name.
+  class Factory {
+   public:
+    explicit Factory(absl::string_view name) : name_(new std::string(name)) {}
+
+    Factory(const Factory&) = delete;
+    Factory& operator=(const Factory&) = delete;
+
+    UniqueTypeName Create() { return UniqueTypeName(*name_); }
+
+   private:
+    std::string* name_;
+  };
+
+  // Copyable.
+  UniqueTypeName(const UniqueTypeName& other) : name_(other.name_) {}
+  UniqueTypeName& operator=(const UniqueTypeName& other) {
+    name_ = other.name_;
+    return *this;
+  }
+
+  bool operator==(const UniqueTypeName& other) const {
+    return name_.data() == other.name_.data();
+  }
+  bool operator!=(const UniqueTypeName& other) const {
+    return name_.data() != other.name_.data();
+  }
+  bool operator<(const UniqueTypeName& other) const {
+    return name_.data() < other.name_.data();
+  }
+
+  int Compare(const UniqueTypeName& other) const {
+    return QsortCompare(name_.data(), other.name_.data());
+  }
+
+  absl::string_view name() const { return name_; }
+
+ private:
+  explicit UniqueTypeName(absl::string_view name) : name_(name) {}
+
+  absl::string_view name_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_GPRPP_UNIQUE_TYPE_NAME_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,127 @@
+// 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_SRC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
+#define GRPC_SRC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <map>
+#include <string>
+#include <utility>
+#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);
+    }
+
+    // Not copyable.
+    ScopedField(const ScopedField& other) = delete;
+    ScopedField& operator=(const ScopedField& other) = delete;
+
+    // Movable.
+    ScopedField(ScopedField&& other) noexcept
+        : errors_(std::exchange(other.errors_, nullptr)) {}
+    ScopedField& operator=(ScopedField&& other) noexcept {
+      if (errors_ != nullptr) errors_->PopField();
+      errors_ = std::exchange(other.errors_, nullptr);
+      return *this;
+    }
+
+    ~ScopedField() {
+      if (errors_ != nullptr) 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_SRC_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,37 +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_SRC_CORE_LIB_GPRPP_WORK_SERIALIZER_H
+#define GRPC_SRC_CORE_LIB_GPRPP_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"
-
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
 
 namespace grpc_core {
 
@@ -88,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_SRC_CORE_LIB_GPRPP_WORK_SERIALIZER_H

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

@@ -0,0 +1,53 @@
+//
+//
+// 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_SRC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
+#define GRPC_SRC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
+
+#include <grpc/support/port_platform.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 {
+
+class ProxyMapperInterface {
+ public:
+  virtual ~ProxyMapperInterface() = default;
+
+  /// Determines the proxy name to resolve for \a server_uri.
+  /// 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 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_SRC_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