grpc 1.18.0 → 1.22.0

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

@@ -21,87 +21,64 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/client_channel/lb_policy.h"
+#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
+#include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
+#include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/gprpp/optional.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_millis
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/slice/slice_hash_table.h"
-#include "src/core/lib/transport/service_config.h"
 
 namespace grpc_core {
 namespace internal {
 
-class ClientChannelMethodParams;
+class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig {
+ public:
+  struct RetryThrottling {
+    intptr_t max_milli_tokens = 0;
+    intptr_t milli_token_ratio = 0;
+  };
 
-// A table mapping from a method name to its method parameters.
-typedef SliceHashTable<RefCountedPtr<ClientChannelMethodParams>>
-    ClientChannelMethodParamsTable;
+  ClientChannelGlobalParsedConfig(
+      RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config,
+      UniquePtr<char> parsed_deprecated_lb_policy,
+      const Optional<RetryThrottling>& retry_throttling,
+      const char* health_check_service_name)
+      : parsed_lb_config_(std::move(parsed_lb_config)),
+        parsed_deprecated_lb_policy_(std::move(parsed_deprecated_lb_policy)),
+        retry_throttling_(retry_throttling),
+        health_check_service_name_(health_check_service_name) {}
+
+  Optional<RetryThrottling> retry_throttling() const {
+    return retry_throttling_;
+  }
 
-// A container of processed fields from the resolver result. Simplifies the
-// usage of resolver result.
-class ProcessedResolverResult {
- public:
-  // Processes the resolver result and populates the relative members
-  // for later consumption. Tries to parse retry parameters only if parse_retry
-  // is true.
-  ProcessedResolverResult(const grpc_channel_args& resolver_result,
-                          bool parse_retry);
-
-  // Getters. Any managed object's ownership is transferred.
-  UniquePtr<char> service_config_json() {
-    return std::move(service_config_json_);
+  RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config() const {
+    return parsed_lb_config_;
   }
-  RefCountedPtr<ServerRetryThrottleData> retry_throttle_data() {
-    return std::move(retry_throttle_data_);
+
+  const char* parsed_deprecated_lb_policy() const {
+    return parsed_deprecated_lb_policy_.get();
   }
-  RefCountedPtr<ClientChannelMethodParamsTable> method_params_table() {
-    return std::move(method_params_table_);
+
+  const char* health_check_service_name() const {
+    return health_check_service_name_;
   }
-  UniquePtr<char> lb_policy_name() { return std::move(lb_policy_name_); }
-  grpc_json* lb_policy_config() { return lb_policy_config_; }
 
  private:
-  // Finds the service config; extracts LB config and (maybe) retry throttle
-  // params from it.
-  void ProcessServiceConfig(const grpc_channel_args& resolver_result,
-                            bool parse_retry);
-
-  // Finds the LB policy name (when no LB config was found).
-  void ProcessLbPolicyName(const grpc_channel_args& resolver_result);
-
-  // Parses the service config. Intended to be used by
-  // ServiceConfig::ParseGlobalParams.
-  static void ParseServiceConfig(const grpc_json* field,
-                                 ProcessedResolverResult* parsing_state);
-  // Parses the LB config from service config.
-  void ParseLbConfigFromServiceConfig(const grpc_json* field);
-  // Parses the retry throttle parameters from service config.
-  void ParseRetryThrottleParamsFromServiceConfig(const grpc_json* field);
-
-  // Service config.
-  UniquePtr<char> service_config_json_;
-  UniquePtr<grpc_core::ServiceConfig> service_config_;
-  // LB policy.
-  grpc_json* lb_policy_config_ = nullptr;
-  UniquePtr<char> lb_policy_name_;
-  // Retry throttle data.
-  char* server_name_ = nullptr;
-  RefCountedPtr<ServerRetryThrottleData> retry_throttle_data_;
-  // Method params table.
-  RefCountedPtr<ClientChannelMethodParamsTable> method_params_table_;
+  RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config_;
+  UniquePtr<char> parsed_deprecated_lb_policy_;
+  Optional<RetryThrottling> retry_throttling_;
+  const char* health_check_service_name_;
 };
 
-// The parameters of a method.
-class ClientChannelMethodParams : public RefCounted<ClientChannelMethodParams> {
+class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig {
  public:
-  enum WaitForReady {
-    WAIT_FOR_READY_UNSET = 0,
-    WAIT_FOR_READY_FALSE,
-    WAIT_FOR_READY_TRUE
-  };
-
   struct RetryPolicy {
     int max_attempts = 0;
     grpc_millis initial_backoff = 0;
@@ -110,30 +87,35 @@ class ClientChannelMethodParams : public RefCounted<ClientChannelMethodParams> {
     StatusCodeSet retryable_status_codes;
   };
 
-  /// Creates a method_parameters object from \a json.
-  /// Intended for use with ServiceConfig::CreateMethodConfigTable().
-  static RefCountedPtr<ClientChannelMethodParams> CreateFromJson(
-      const grpc_json* json);
+  ClientChannelMethodParsedConfig(grpc_millis timeout,
+                                  const Optional<bool>& wait_for_ready,
+                                  UniquePtr<RetryPolicy> retry_policy)
+      : timeout_(timeout),
+        wait_for_ready_(wait_for_ready),
+        retry_policy_(std::move(retry_policy)) {}
 
   grpc_millis timeout() const { return timeout_; }
-  WaitForReady wait_for_ready() const { return wait_for_ready_; }
+
+  Optional<bool> wait_for_ready() const { return wait_for_ready_; }
+
   const RetryPolicy* retry_policy() const { return retry_policy_.get(); }
 
  private:
-  // So New() can call our private ctor.
-  template <typename T, typename... Args>
-  friend T* grpc_core::New(Args&&... args);
+  grpc_millis timeout_ = 0;
+  Optional<bool> wait_for_ready_;
+  UniquePtr<RetryPolicy> retry_policy_;
+};
 
-  // So Delete() can call our private dtor.
-  template <typename T>
-  friend void grpc_core::Delete(T*);
+class ClientChannelServiceConfigParser : public ServiceConfig::Parser {
+ public:
+  UniquePtr<ServiceConfig::ParsedConfig> ParseGlobalParams(
+      const grpc_json* json, grpc_error** error) override;
 
-  ClientChannelMethodParams() {}
-  virtual ~ClientChannelMethodParams() {}
+  UniquePtr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
+      const grpc_json* json, grpc_error** error) override;
 
-  grpc_millis timeout_ = 0;
-  WaitForReady wait_for_ready_ = WAIT_FOR_READY_UNSET;
-  UniquePtr<RetryPolicy> retry_policy_;
+  static size_t ParserIndex();
+  static void Register();
 };
 
 }  // namespace internal