grpc 1.50.0.pre1 → 1.51.0

data/src/core/ext/filters/client_channel/retry_service_config.cc

@@ -18,17 +18,12 @@
 
 #include "src/core/ext/filters/client_channel/retry_service_config.h"
 
-#include <stdio.h>
-#include <string.h>
-
-#include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
-#include "absl/status/status.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
@@ -39,9 +34,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/json/json_util.h"
+#include "src/core/lib/json/json_channel_args.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
 #define MAX_MAX_RETRY_ATTEMPTS 5
@@ -49,275 +42,240 @@
 namespace grpc_core {
 namespace internal {
 
-size_t RetryServiceConfigParser::ParserIndex() {
-  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
-      parser_name());
-}
+//
+// RetryGlobalConfig
+//
 
-void RetryServiceConfigParser::Register(CoreConfiguration::Builder* builder) {
-  builder->service_config_parser()->RegisterParser(
-      absl::make_unique<RetryServiceConfigParser>());
+const JsonLoaderInterface* RetryGlobalConfig::JsonLoader(const JsonArgs&) {
+  // Note: Both fields require custom processing, so they're handled in
+  // JsonPostLoad() instead.
+  static const auto* loader = JsonObjectLoader<RetryGlobalConfig>().Finish();
+  return loader;
 }
 
-namespace {
-
-grpc_error_handle ParseRetryThrottling(const Json& json,
-                                       intptr_t* max_milli_tokens,
-                                       intptr_t* milli_token_ratio) {
-  if (json.type() != Json::Type::OBJECT) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryThrottling error:Type should be object");
-  }
-  std::vector<grpc_error_handle> error_list;
+void RetryGlobalConfig::JsonPostLoad(const Json& json, const JsonArgs& args,
+                                     ValidationErrors* errors) {
   // Parse maxTokens.
-  auto it = json.object_value().find("maxTokens");
-  if (it == json.object_value().end()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryThrottling field:maxTokens error:Not found"));
-  } else if (it->second.type() != Json::Type::NUMBER) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryThrottling field:maxTokens error:Type should be "
-        "number"));
-  } else {
-    *max_milli_tokens =
-        gpr_parse_nonnegative_int(it->second.string_value().c_str()) * 1000;
-    if (*max_milli_tokens <= 0) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:retryThrottling field:maxTokens error:should be "
-          "greater than zero"));
+  auto max_tokens = LoadJsonObjectField<uint32_t>(json.object_value(), args,
+                                                  "maxTokens", errors);
+  if (max_tokens.has_value()) {
+    ValidationErrors::ScopedField field(errors, ".maxTokens");
+    if (*max_tokens == 0) {
+      errors->AddError("must be greater than 0");
+    } else {
+      // Multiply by 1000 to represent as milli-tokens.
+      max_milli_tokens_ = static_cast<uintptr_t>(*max_tokens) * 1000;
     }
   }
   // Parse tokenRatio.
-  it = json.object_value().find("tokenRatio");
+  ValidationErrors::ScopedField field(errors, ".tokenRatio");
+  auto it = json.object_value().find("tokenRatio");
   if (it == json.object_value().end()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryThrottling field:tokenRatio error:Not found"));
-  } else if (it->second.type() != Json::Type::NUMBER) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryThrottling field:tokenRatio error:type should be "
-        "number"));
-  } else {
+    errors->AddError("field not present");
+    return;
+  }
+  if (it->second.type() != Json::Type::NUMBER &&
+      it->second.type() != Json::Type::STRING) {
+    errors->AddError("is not a number");
+    return;
+  }
+  absl::string_view buf = it->second.string_value();
+  uint32_t multiplier = 1;
+  uint32_t decimal_value = 0;
+  auto decimal_point = buf.find('.');
+  if (decimal_point != absl::string_view::npos) {
+    absl::string_view after_decimal = buf.substr(decimal_point + 1);
+    buf = buf.substr(0, decimal_point);
     // We support up to 3 decimal digits.
-    size_t whole_len = it->second.string_value().size();
-    const char* value = it->second.string_value().c_str();
-    uint32_t multiplier = 1;
-    uint32_t decimal_value = 0;
-    const char* decimal_point = strchr(value, '.');
-    if (decimal_point != nullptr) {
-      whole_len = static_cast<size_t>(decimal_point - value);
-      multiplier = 1000;
-      size_t decimal_len = strlen(decimal_point + 1);
-      if (decimal_len > 3) decimal_len = 3;
-      if (!gpr_parse_bytes_to_uint32(decimal_point + 1, decimal_len,
-                                     &decimal_value)) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryThrottling field:tokenRatio error:Failed "
-            "parsing"));
-        return GRPC_ERROR_CREATE_FROM_VECTOR("retryThrottling", &error_list);
-      }
-      uint32_t decimal_multiplier = 1;
-      for (size_t i = 0; i < (3 - decimal_len); ++i) {
-        decimal_multiplier *= 10;
-      }
-      decimal_value *= decimal_multiplier;
-    }
-    uint32_t whole_value;
-    if (!gpr_parse_bytes_to_uint32(value, whole_len, &whole_value)) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:retryThrottling field:tokenRatio error:Failed "
-          "parsing"));
-      return GRPC_ERROR_CREATE_FROM_VECTOR("retryThrottling", &error_list);
+    multiplier = 1000;
+    if (after_decimal.length() > 3) after_decimal = after_decimal.substr(0, 3);
+    // Parse decimal value.
+    if (!absl::SimpleAtoi(after_decimal, &decimal_value)) {
+      errors->AddError("could not parse as a number");
+      return;
     }
-    *milli_token_ratio =
-        static_cast<int>((whole_value * multiplier) + decimal_value);
-    if (*milli_token_ratio <= 0) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:retryThrottling field:tokenRatio error:value should "
-          "be greater than 0"));
+    uint32_t decimal_multiplier = 1;
+    for (size_t i = 0; i < (3 - after_decimal.length()); ++i) {
+      decimal_multiplier *= 10;
     }
+    decimal_value *= decimal_multiplier;
+  }
+  uint32_t whole_value;
+  if (!absl::SimpleAtoi(buf, &whole_value)) {
+    errors->AddError("could not parse as a number");
+    return;
+  }
+  milli_token_ratio_ =
+      static_cast<int>((whole_value * multiplier) + decimal_value);
+  if (milli_token_ratio_ <= 0) {
+    errors->AddError("must be greater than 0");
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("retryThrottling", &error_list);
 }
 
-}  // namespace
+//
+// RetryMethodConfig
+//
 
-absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-RetryServiceConfigParser::ParseGlobalParams(const ChannelArgs& /*args*/,
-                                            const Json& json) {
-  auto it = json.object_value().find("retryThrottling");
-  if (it == json.object_value().end()) return nullptr;
-  intptr_t max_milli_tokens = 0;
-  intptr_t milli_token_ratio = 0;
-  grpc_error_handle error =
-      ParseRetryThrottling(it->second, &max_milli_tokens, &milli_token_ratio);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    absl::Status status = absl::InvalidArgumentError(
-        absl::StrCat("error parsing retry global parameters: ",
-                     grpc_error_std_string(error)));
-    GRPC_ERROR_UNREF(error);
-    return status;
-  }
-  return absl::make_unique<RetryGlobalConfig>(max_milli_tokens,
-                                              milli_token_ratio);
+const JsonLoaderInterface* RetryMethodConfig::JsonLoader(const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<RetryMethodConfig>()
+          // Note: The "retryableStatusCodes" field requires custom parsing,
+          // so it's handled in JsonPostLoad() instead.
+          .Field("maxAttempts", &RetryMethodConfig::max_attempts_)
+          .Field("initialBackoff", &RetryMethodConfig::initial_backoff_)
+          .Field("maxBackoff", &RetryMethodConfig::max_backoff_)
+          .Field("backoffMultiplier", &RetryMethodConfig::backoff_multiplier_)
+          .OptionalField("perAttemptRecvTimeout",
+                         &RetryMethodConfig::per_attempt_recv_timeout_,
+                         GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING)
+          .Finish();
+  return loader;
 }
 
-namespace {
-
-grpc_error_handle ParseRetryPolicy(
-    const ChannelArgs& args, const Json& json, int* max_attempts,
-    Duration* initial_backoff, Duration* max_backoff, float* backoff_multiplier,
-    StatusCodeSet* retryable_status_codes,
-    absl::optional<Duration>* per_attempt_recv_timeout) {
-  if (json.type() != Json::Type::OBJECT) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryPolicy error:should be of type object");
-  }
-  std::vector<grpc_error_handle> error_list;
-  // Parse maxAttempts.
-  auto it = json.object_value().find("maxAttempts");
-  if (it == json.object_value().end()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:maxAttempts error:required field missing"));
-  } else {
-    if (it->second.type() != Json::Type::NUMBER) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:maxAttempts error:should be of type number"));
-    } else {
-      *max_attempts =
-          gpr_parse_nonnegative_int(it->second.string_value().c_str());
-      if (*max_attempts <= 1) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxAttempts error:should be at least 2"));
-      } else if (*max_attempts > MAX_MAX_RETRY_ATTEMPTS) {
+void RetryMethodConfig::JsonPostLoad(const Json& json, const JsonArgs& args,
+                                     ValidationErrors* errors) {
+  // Validate maxAttempts.
+  {
+    ValidationErrors::ScopedField field(errors, ".maxAttempts");
+    if (!errors->FieldHasErrors()) {
+      if (max_attempts_ <= 1) {
+        errors->AddError("must be at least 2");
+      } else if (max_attempts_ > MAX_MAX_RETRY_ATTEMPTS) {
         gpr_log(GPR_ERROR,
                 "service config: clamped retryPolicy.maxAttempts at %d",
                 MAX_MAX_RETRY_ATTEMPTS);
-        *max_attempts = MAX_MAX_RETRY_ATTEMPTS;
+        max_attempts_ = MAX_MAX_RETRY_ATTEMPTS;
       }
     }
   }
-  // Parse initialBackoff.
-  if (ParseJsonObjectFieldAsDuration(json.object_value(), "initialBackoff",
-                                     initial_backoff, &error_list) &&
-      *initial_backoff == Duration::Zero()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:initialBackoff error:must be greater than 0"));
+  // Validate initialBackoff.
+  {
+    ValidationErrors::ScopedField field(errors, ".initialBackoff");
+    if (!errors->FieldHasErrors() && initial_backoff_ == Duration::Zero()) {
+      errors->AddError("must be greater than 0");
+    }
   }
-  // Parse maxBackoff.
-  if (ParseJsonObjectFieldAsDuration(json.object_value(), "maxBackoff",
-                                     max_backoff, &error_list) &&
-      *max_backoff == Duration::Zero()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:maxBackoff error:must be greater than 0"));
+  // Validate maxBackoff.
+  {
+    ValidationErrors::ScopedField field(errors, ".maxBackoff");
+    if (!errors->FieldHasErrors() && max_backoff_ == Duration::Zero()) {
+      errors->AddError("must be greater than 0");
+    }
   }
-  // Parse backoffMultiplier.
-  it = json.object_value().find("backoffMultiplier");
-  if (it == json.object_value().end()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:backoffMultiplier error:required field missing"));
-  } else {
-    if (it->second.type() != Json::Type::NUMBER) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:backoffMultiplier error:should be of type number"));
-    } else {
-      if (sscanf(it->second.string_value().c_str(), "%f", backoff_multiplier) !=
-          1) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:backoffMultiplier error:failed to parse"));
-      } else if (*backoff_multiplier <= 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:backoffMultiplier error:must be greater than 0"));
-      }
+  // Validate backoffMultiplier.
+  {
+    ValidationErrors::ScopedField field(errors, ".backoffMultiplier");
+    if (!errors->FieldHasErrors() && backoff_multiplier_ <= 0) {
+      errors->AddError("must be greater than 0");
     }
   }
   // Parse retryableStatusCodes.
-  it = json.object_value().find("retryableStatusCodes");
-  if (it != json.object_value().end()) {
-    if (it->second.type() != Json::Type::ARRAY) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:retryableStatusCodes error:must be of type array"));
-    } else {
-      for (const Json& element : it->second.array_value()) {
-        if (element.type() != Json::Type::STRING) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:retryableStatusCodes error:status codes should be of type "
-              "string"));
-          continue;
-        }
-        grpc_status_code status;
-        if (!grpc_status_code_from_string(element.string_value().c_str(),
-                                          &status)) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:retryableStatusCodes error:failed to parse status code"));
-          continue;
-        }
-        retryable_status_codes->Add(status);
+  auto status_code_list = LoadJsonObjectField<std::vector<std::string>>(
+      json.object_value(), args, "retryableStatusCodes", errors,
+      /*required=*/false);
+  if (status_code_list.has_value()) {
+    for (size_t i = 0; i < status_code_list->size(); ++i) {
+      ValidationErrors::ScopedField field(
+          errors, absl::StrCat(".retryableStatusCodes[", i, "]"));
+      grpc_status_code status;
+      if (!grpc_status_code_from_string((*status_code_list)[i].c_str(),
+                                        &status)) {
+        errors->AddError("failed to parse status code");
+      } else {
+        retryable_status_codes_.Add(status);
       }
     }
   }
-  // Parse perAttemptRecvTimeout.
-  if (args.GetBool(GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING).value_or(false)) {
-    it = json.object_value().find("perAttemptRecvTimeout");
-    if (it != json.object_value().end()) {
-      Duration per_attempt_recv_timeout_value;
-      if (!ParseDurationFromJson(it->second, &per_attempt_recv_timeout_value)) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:perAttemptRecvTimeout error:type must be STRING of the "
-            "form given by google.proto.Duration."));
-      } else {
-        *per_attempt_recv_timeout = per_attempt_recv_timeout_value;
-        // TODO(roth): As part of implementing hedging, relax this check such
-        // that we allow a value of 0 if a hedging policy is specified.
-        if (per_attempt_recv_timeout_value == Duration::Zero()) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:perAttemptRecvTimeout error:must be greater than 0"));
-        }
+  // Validate perAttemptRecvTimeout.
+  if (args.IsEnabled(GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING)) {
+    if (per_attempt_recv_timeout_.has_value()) {
+      ValidationErrors::ScopedField field(errors, ".perAttemptRecvTimeout");
+      // TODO(roth): As part of implementing hedging, relax this check such
+      // that we allow a value of 0 if a hedging policy is specified.
+      if (!errors->FieldHasErrors() &&
+          *per_attempt_recv_timeout_ == Duration::Zero()) {
+        errors->AddError("must be greater than 0");
       }
-    } else if (retryable_status_codes->Empty()) {
+    } else if (retryable_status_codes_.Empty()) {
       // If perAttemptRecvTimeout not present, retryableStatusCodes must be
       // non-empty.
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:retryableStatusCodes error:must be non-empty if "
-          "perAttemptRecvTimeout not present"));
+      ValidationErrors::ScopedField field(errors, ".retryableStatusCodes");
+      if (!errors->FieldHasErrors()) {
+        errors->AddError(
+            "must be non-empty if perAttemptRecvTimeout not present");
+      }
     }
-  } else {
+  } else if (retryable_status_codes_.Empty()) {
     // Hedging not enabled, so the error message for
     // retryableStatusCodes unset should be different.
-    if (retryable_status_codes->Empty()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:retryableStatusCodes error:must be non-empty"));
+    ValidationErrors::ScopedField field(errors, ".retryableStatusCodes");
+    if (!errors->FieldHasErrors()) {
+      errors->AddError("must be non-empty");
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
 }
 
+//
+// RetryServiceConfigParser
+//
+
+size_t RetryServiceConfigParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+void RetryServiceConfigParser::Register(CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      std::make_unique<RetryServiceConfigParser>());
+}
+
+namespace {
+
+struct GlobalConfig {
+  std::unique_ptr<RetryGlobalConfig> retry_throttling;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<GlobalConfig>()
+            .OptionalField("retryThrottling", &GlobalConfig::retry_throttling)
+            .Finish();
+    return loader;
+  }
+};
+
+}  // namespace
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+RetryServiceConfigParser::ParseGlobalParams(const ChannelArgs& /*args*/,
+                                            const Json& json,
+                                            ValidationErrors* errors) {
+  auto global_params = LoadFromJson<GlobalConfig>(json, JsonArgs(), errors);
+  return std::move(global_params.retry_throttling);
+}
+
+namespace {
+
+struct MethodConfig {
+  std::unique_ptr<RetryMethodConfig> retry_policy;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<MethodConfig>()
+            .OptionalField("retryPolicy", &MethodConfig::retry_policy)
+            .Finish();
+    return loader;
+  }
+};
+
 }  // namespace
 
-absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
 RetryServiceConfigParser::ParsePerMethodParams(const ChannelArgs& args,
-                                               const Json& json) {
-  // Parse retry policy.
-  auto it = json.object_value().find("retryPolicy");
-  if (it == json.object_value().end()) return nullptr;
-  int max_attempts = 0;
-  Duration initial_backoff;
-  Duration max_backoff;
-  float backoff_multiplier = 0;
-  StatusCodeSet retryable_status_codes;
-  absl::optional<Duration> per_attempt_recv_timeout;
-  grpc_error_handle error = ParseRetryPolicy(
-      args, it->second, &max_attempts, &initial_backoff, &max_backoff,
-      &backoff_multiplier, &retryable_status_codes, &per_attempt_recv_timeout);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    absl::Status status = absl::InvalidArgumentError(
-        absl::StrCat("error parsing retry method parameters: ",
-                     grpc_error_std_string(error)));
-    GRPC_ERROR_UNREF(error);
-    return status;
-  }
-  return absl::make_unique<RetryMethodConfig>(
-      max_attempts, initial_backoff, max_backoff, backoff_multiplier,
-      retryable_status_codes, per_attempt_recv_timeout);
+                                               const Json& json,
+                                               ValidationErrors* errors) {
+  auto method_params =
+      LoadFromJson<MethodConfig>(json, JsonChannelArgs(args), errors);
+  return std::move(method_params.retry_policy);
 }
 
 }  // namespace internal

data/src/core/ext/filters/client_channel/retry_service_config.h

@@ -24,7 +24,6 @@
 
 #include <memory>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -32,7 +31,10 @@
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
 namespace grpc_core {
@@ -40,31 +42,20 @@ namespace internal {
 
 class RetryGlobalConfig : public ServiceConfigParser::ParsedConfig {
  public:
-  RetryGlobalConfig(intptr_t max_milli_tokens, intptr_t milli_token_ratio)
-      : max_milli_tokens_(max_milli_tokens),
-        milli_token_ratio_(milli_token_ratio) {}
+  uintptr_t max_milli_tokens() const { return max_milli_tokens_; }
+  uintptr_t milli_token_ratio() const { return milli_token_ratio_; }
 
-  intptr_t max_milli_tokens() const { return max_milli_tokens_; }
-  intptr_t milli_token_ratio() const { return milli_token_ratio_; }
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs& args,
+                    ValidationErrors* errors);
 
  private:
-  intptr_t max_milli_tokens_ = 0;
-  intptr_t milli_token_ratio_ = 0;
+  uintptr_t max_milli_tokens_ = 0;
+  uintptr_t milli_token_ratio_ = 0;
 };
 
 class RetryMethodConfig : public ServiceConfigParser::ParsedConfig {
  public:
-  RetryMethodConfig(int max_attempts, Duration initial_backoff,
-                    Duration max_backoff, float backoff_multiplier,
-                    StatusCodeSet retryable_status_codes,
-                    absl::optional<Duration> per_attempt_recv_timeout)
-      : max_attempts_(max_attempts),
-        initial_backoff_(initial_backoff),
-        max_backoff_(max_backoff),
-        backoff_multiplier_(backoff_multiplier),
-        retryable_status_codes_(retryable_status_codes),
-        per_attempt_recv_timeout_(per_attempt_recv_timeout) {}
-
   int max_attempts() const { return max_attempts_; }
   Duration initial_backoff() const { return initial_backoff_; }
   Duration max_backoff() const { return max_backoff_; }
@@ -76,6 +67,10 @@ class RetryMethodConfig : public ServiceConfigParser::ParsedConfig {
     return per_attempt_recv_timeout_;
   }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs& args,
+                    ValidationErrors* errors);
+
  private:
   int max_attempts_ = 0;
   Duration initial_backoff_;
@@ -89,11 +84,13 @@ class RetryServiceConfigParser : public ServiceConfigParser::Parser {
  public:
   absl::string_view name() const override { return parser_name(); }
 
-  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-  ParseGlobalParams(const ChannelArgs& /*args*/, const Json& json) override;
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
+      const ChannelArgs& /*args*/, const Json& json,
+      ValidationErrors* errors) override;
 
-  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-  ParsePerMethodParams(const ChannelArgs& args, const Json& json) override;
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const ChannelArgs& args, const Json& json,
+      ValidationErrors* errors) override;
 
   static size_t ParserIndex();
   static void Register(CoreConfiguration::Builder* builder);

data/src/core/ext/filters/client_channel/retry_throttle.cc

@@ -34,22 +34,22 @@ namespace internal {
 //
 
 ServerRetryThrottleData::ServerRetryThrottleData(
-    intptr_t max_milli_tokens, intptr_t milli_token_ratio,
+    uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
     ServerRetryThrottleData* old_throttle_data)
     : max_milli_tokens_(max_milli_tokens),
       milli_token_ratio_(milli_token_ratio) {
-  intptr_t initial_milli_tokens = max_milli_tokens;
+  uintptr_t initial_milli_tokens = max_milli_tokens;
   // If there was a pre-existing entry for this server name, initialize
   // the token count by scaling proportionately to the old data.  This
   // ensures that if we're already throttling retries on the old scale,
   // we will start out doing the same thing on the new one.
   if (old_throttle_data != nullptr) {
     double token_fraction =
-        static_cast<intptr_t>(
+        static_cast<uintptr_t>(
             gpr_atm_acq_load(&old_throttle_data->milli_tokens_)) /
         static_cast<double>(old_throttle_data->max_milli_tokens_);
     initial_milli_tokens =
-        static_cast<intptr_t>(token_fraction * max_milli_tokens);
+        static_cast<uintptr_t>(token_fraction * max_milli_tokens);
   }
   gpr_atm_rel_store(&milli_tokens_, static_cast<gpr_atm>(initial_milli_tokens));
   // If there was a pre-existing entry, mark it as stale and give it a
@@ -86,8 +86,8 @@ bool ServerRetryThrottleData::RecordFailure() {
   ServerRetryThrottleData* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We decrement milli_tokens by 1000 (1 token) for each failure.
-  const intptr_t new_value =
-      static_cast<intptr_t>(gpr_atm_no_barrier_clamped_add(
+  const uintptr_t new_value =
+      static_cast<uintptr_t>(gpr_atm_no_barrier_clamped_add(
           &throttle_data->milli_tokens_, static_cast<gpr_atm>(-1000),
           static_cast<gpr_atm>(0),
           static_cast<gpr_atm>(throttle_data->max_milli_tokens_)));
@@ -118,8 +118,8 @@ ServerRetryThrottleMap* ServerRetryThrottleMap::Get() {
 }
 
 RefCountedPtr<ServerRetryThrottleData> ServerRetryThrottleMap::GetDataForServer(
-    const std::string& server_name, intptr_t max_milli_tokens,
-    intptr_t milli_token_ratio) {
+    const std::string& server_name, uintptr_t max_milli_tokens,
+    uintptr_t milli_token_ratio) {
   MutexLock lock(&mu_);
   auto it = map_.find(server_name);
   ServerRetryThrottleData* throttle_data =