grpc 1.44.0.pre2 → 1.46.3

data/src/core/lib/service_config/{service_config.cc → service_config_impl.cc}

@@ -1,5 +1,5 @@
 //
-// Copyright 2015 gRPC authors.
+// 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.
@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/service_config/service_config_impl.h"
 
 #include <string>
 
@@ -24,25 +24,26 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {
 
-RefCountedPtr<ServiceConfig> ServiceConfig::Create(
+RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
     const grpc_channel_args* args, absl::string_view json_string,
     grpc_error_handle* error) {
   GPR_DEBUG_ASSERT(error != nullptr);
   Json json = Json::Parse(json_string, error);
   if (*error != GRPC_ERROR_NONE) return nullptr;
-  return MakeRefCounted<ServiceConfig>(args, std::string(json_string),
-                                       std::move(json), error);
+  return MakeRefCounted<ServiceConfigImpl>(args, std::string(json_string),
+                                           std::move(json), error);
 }
 
-ServiceConfig::ServiceConfig(const grpc_channel_args* args,
-                             std::string json_string, Json json,
-                             grpc_error_handle* error)
+ServiceConfigImpl::ServiceConfigImpl(const grpc_channel_args* args,
+                                     std::string json_string, Json json,
+                                     grpc_error_handle* error)
     : json_string_(std::move(json_string)), json_(std::move(json)) {
   GPR_DEBUG_ASSERT(error != nullptr);
   if (json_.type() != Json::Type::OBJECT) {
@@ -53,7 +54,8 @@ ServiceConfig::ServiceConfig(const grpc_channel_args* args,
   std::vector<grpc_error_handle> error_list;
   grpc_error_handle global_error = GRPC_ERROR_NONE;
   parsed_global_configs_ =
-      ServiceConfigParser::ParseGlobalParameters(args, json_, &global_error);
+      CoreConfiguration::Get().service_config_parser().ParseGlobalParameters(
+          args, json_, &global_error);
   if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
   grpc_error_handle local_error = ParsePerMethodParams(args);
   if (local_error != GRPC_ERROR_NONE) error_list.push_back(local_error);
@@ -63,13 +65,13 @@ ServiceConfig::ServiceConfig(const grpc_channel_args* args,
   }
 }
 
-ServiceConfig::~ServiceConfig() {
+ServiceConfigImpl::~ServiceConfigImpl() {
   for (auto& p : parsed_method_configs_map_) {
     grpc_slice_unref_internal(p.first);
   }
 }
 
-grpc_error_handle ServiceConfig::ParseJsonMethodConfig(
+grpc_error_handle ServiceConfigImpl::ParseJsonMethodConfig(
     const grpc_channel_args* args, const Json& json) {
   std::vector<grpc_error_handle> error_list;
   // Parse method config with each registered parser.
@@ -77,7 +79,8 @@ grpc_error_handle ServiceConfig::ParseJsonMethodConfig(
       absl::make_unique<ServiceConfigParser::ParsedConfigVector>();
   grpc_error_handle parser_error = GRPC_ERROR_NONE;
   *parsed_configs =
-      ServiceConfigParser::ParsePerMethodParameters(args, json, &parser_error);
+      CoreConfiguration::Get().service_config_parser().ParsePerMethodParameters(
+          args, json, &parser_error);
   if (parser_error != GRPC_ERROR_NONE) {
     error_list.push_back(parser_error);
   }
@@ -130,7 +133,7 @@ grpc_error_handle ServiceConfig::ParseJsonMethodConfig(
   return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
 }
 
-grpc_error_handle ServiceConfig::ParsePerMethodParams(
+grpc_error_handle ServiceConfigImpl::ParsePerMethodParams(
     const grpc_channel_args* args) {
   std::vector<grpc_error_handle> error_list;
   auto it = json_.object_value().find("methodConfig");
@@ -154,8 +157,8 @@ grpc_error_handle ServiceConfig::ParsePerMethodParams(
   return GRPC_ERROR_CREATE_FROM_VECTOR("Method Params", &error_list);
 }
 
-std::string ServiceConfig::ParseJsonMethodName(const Json& json,
-                                               grpc_error_handle* error) {
+std::string ServiceConfigImpl::ParseJsonMethodName(const Json& json,
+                                                   grpc_error_handle* error) {
   if (json.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:name error:type is not object");
@@ -204,7 +207,7 @@ std::string ServiceConfig::ParseJsonMethodName(const Json& json,
 }
 
 const ServiceConfigParser::ParsedConfigVector*
-ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) const {
+ServiceConfigImpl::GetMethodParsedConfigVector(const grpc_slice& path) const {
   if (parsed_method_configs_map_.empty()) {
     return default_method_config_vector_;
   }

data/src/core/lib/service_config/service_config_impl.h

@@ -0,0 +1,125 @@
+//
+// 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_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H
+#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <unordered_map>
+#include <vector>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/service_config/service_config_parser.h"
+#include "src/core/lib/slice/slice_internal.h"
+
+// The main purpose of the code here is to parse the service config in
+// JSON form, which will look like this:
+//
+// {
+//   "loadBalancingPolicy": "string",  // optional
+//   "methodConfig": [  // array of one or more method_config objects
+//     {
+//       "name": [  // array of one or more name objects
+//         {
+//           "service": "string",  // required
+//           "method": "string",  // optional
+//         }
+//       ],
+//       // remaining fields are optional.
+//       // see https://developers.google.com/protocol-buffers/docs/proto3#json
+//       // for format details.
+//       "waitForReady": bool,
+//       "timeout": "duration_string",
+//       "maxRequestMessageBytes": "int64_string",
+//       "maxResponseMessageBytes": "int64_string",
+//     }
+//   ]
+// }
+
+namespace grpc_core {
+
+class ServiceConfigImpl final : public ServiceConfig {
+ public:
+  /// Creates a new service config from parsing \a json_string.
+  /// Returns null on parse error.
+  static RefCountedPtr<ServiceConfig> Create(const grpc_channel_args* args,
+                                             absl::string_view json_string,
+                                             grpc_error_handle* error);
+
+  ServiceConfigImpl(const grpc_channel_args* args, std::string json_string,
+                    Json json, grpc_error_handle* error);
+  ~ServiceConfigImpl() override;
+
+  absl::string_view json_string() const override { return json_string_; }
+
+  /// Retrieves the global parsed config at index \a index. The
+  /// lifetime of the returned object is tied to the lifetime of the
+  /// ServiceConfig object.
+  ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(
+      size_t index) override {
+    GPR_DEBUG_ASSERT(index < parsed_global_configs_.size());
+    return parsed_global_configs_[index].get();
+  }
+
+  /// Retrieves the vector of parsed configs for the method identified
+  /// by \a path.  The lifetime of the returned vector and contained objects
+  /// is tied to the lifetime of the ServiceConfig object.
+  const ServiceConfigParser::ParsedConfigVector* GetMethodParsedConfigVector(
+      const grpc_slice& path) const override;
+
+ private:
+  // Helper functions for parsing the method configs.
+  grpc_error_handle ParsePerMethodParams(const grpc_channel_args* args);
+  grpc_error_handle ParseJsonMethodConfig(const grpc_channel_args* args,
+                                          const Json& json);
+
+  // Returns a path string for the JSON name object specified by json.
+  // Sets *error on error.
+  static std::string ParseJsonMethodName(const Json& json,
+                                         grpc_error_handle* error);
+
+  std::string json_string_;
+  Json json_;
+
+  std::vector<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
+      parsed_global_configs_;
+  // A map from the method name to the parsed config vector. Note that we are
+  // using a raw pointer and not a unique pointer so that we can use the same
+  // vector for multiple names.
+  std::unordered_map<grpc_slice, const ServiceConfigParser::ParsedConfigVector*,
+                     SliceHash>
+      parsed_method_configs_map_;
+  // Default method config.
+  const ServiceConfigParser::ParsedConfigVector* default_method_config_vector_ =
+      nullptr;
+  // Storage for all the vectors that are being used in
+  // parsed_method_configs_table_.
+  absl::InlinedVector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>,
+                      32>
+      parsed_method_config_vectors_storage_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H */

data/src/core/lib/service_config/service_config_parser.cc

@@ -22,38 +22,35 @@
 
 namespace grpc_core {
 
-namespace {
-typedef absl::InlinedVector<std::unique_ptr<ServiceConfigParser::Parser>,
-                            ServiceConfigParser::kNumPreallocatedParsers>
-    ServiceConfigParserList;
-ServiceConfigParserList* g_registered_parsers;
-}  // namespace
-
-void ServiceConfigParserInit() {
-  GPR_ASSERT(g_registered_parsers == nullptr);
-  g_registered_parsers = new ServiceConfigParserList();
-}
-
-void ServiceConfigParserShutdown() {
-  delete g_registered_parsers;
-  g_registered_parsers = nullptr;
+ServiceConfigParser ServiceConfigParser::Builder::Build() {
+  return ServiceConfigParser(std::move(registered_parsers_));
 }
 
-size_t ServiceConfigParser::RegisterParser(std::unique_ptr<Parser> parser) {
-  g_registered_parsers->push_back(std::move(parser));
-  return g_registered_parsers->size() - 1;
+void ServiceConfigParser::Builder::RegisterParser(
+    std::unique_ptr<Parser> parser) {
+  for (const auto& registered_parser : registered_parsers_) {
+    if (registered_parser->name() == parser->name()) {
+      gpr_log(GPR_ERROR, "%s",
+              absl::StrCat("Parser with name '", parser->name(),
+                           "' already registered")
+                  .c_str());
+      // We'll otherwise crash later.
+      abort();
+    }
+  }
+  registered_parsers_.emplace_back(std::move(parser));
 }
 
 ServiceConfigParser::ParsedConfigVector
 ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
                                            const Json& json,
-                                           grpc_error_handle* error) {
+                                           grpc_error_handle* error) const {
   ParsedConfigVector parsed_global_configs;
   std::vector<grpc_error_handle> error_list;
-  for (size_t i = 0; i < g_registered_parsers->size(); i++) {
+  for (size_t i = 0; i < registered_parsers_.size(); i++) {
     grpc_error_handle parser_error = GRPC_ERROR_NONE;
-    auto parsed_config = (*g_registered_parsers)[i]->ParseGlobalParams(
-        args, json, &parser_error);
+    auto parsed_config =
+        registered_parsers_[i]->ParseGlobalParams(args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
       error_list.push_back(parser_error);
     }
@@ -68,13 +65,13 @@ ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
 ServiceConfigParser::ParsedConfigVector
 ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
                                               const Json& json,
-                                              grpc_error_handle* error) {
+                                              grpc_error_handle* error) const {
   ParsedConfigVector parsed_method_configs;
   std::vector<grpc_error_handle> error_list;
-  for (size_t i = 0; i < g_registered_parsers->size(); i++) {
+  for (size_t i = 0; i < registered_parsers_.size(); ++i) {
     grpc_error_handle parser_error = GRPC_ERROR_NONE;
-    auto parsed_config = (*g_registered_parsers)[i]->ParsePerMethodParams(
-        args, json, &parser_error);
+    auto parsed_config =
+        registered_parsers_[i]->ParsePerMethodParams(args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
       error_list.push_back(parser_error);
     }
@@ -86,4 +83,11 @@ ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
   return parsed_method_configs;
 }
 
+size_t ServiceConfigParser::GetParserIndex(absl::string_view name) const {
+  for (size_t i = 0; i < registered_parsers_.size(); ++i) {
+    if (registered_parsers_[i]->name() == name) return i;
+  }
+  return -1;
+}
+
 }  // namespace grpc_core

data/src/core/lib/service_config/service_config_parser.h

@@ -20,8 +20,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
-
-#include "absl/container/inlined_vector.h"
+#include <vector>
 
 #include <grpc/impl/codegen/grpc_types.h>
 
@@ -30,11 +29,6 @@
 
 namespace grpc_core {
 
-// Initialization functions for ServiceConfigParser. ServiceConfigParser should
-// be initialized before any parser implementation is registered.
-void ServiceConfigParserInit();
-void ServiceConfigParserShutdown();
-
 // Service config parser registry.
 // See service_config.h for more information.
 class ServiceConfigParser {
@@ -51,6 +45,8 @@ class ServiceConfigParser {
    public:
     virtual ~Parser() = default;
 
+    virtual absl::string_view name() const = 0;
+
     virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
         const grpc_channel_args*, const Json& /* json */,
         grpc_error_handle* error) {
@@ -70,26 +66,39 @@ class ServiceConfigParser {
     }
   };
 
-  static constexpr int kNumPreallocatedParsers = 4;
-  typedef absl::InlinedVector<std::unique_ptr<ParsedConfig>,
-                              kNumPreallocatedParsers>
-      ParsedConfigVector;
-
-  /// Globally register a service config parser. On successful registration, it
-  /// returns the index at which the parser was registered. On failure, -1 is
-  /// returned. Each new service config update will go through all the
-  /// registered parser. Each parser is responsible for reading the service
-  /// config json and returning a parsed config. This parsed config can later be
-  /// retrieved using the same index that was returned at registration time.
-  static size_t RegisterParser(std::unique_ptr<Parser> parser);
-
-  static ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
-                                                  const Json& json,
-                                                  grpc_error_handle* error);
-
-  static ParsedConfigVector ParsePerMethodParameters(
-      const grpc_channel_args* args, const Json& json,
-      grpc_error_handle* error);
+  using ServiceConfigParserList = std::vector<std::unique_ptr<Parser>>;
+  using ParsedConfigVector = std::vector<std::unique_ptr<ParsedConfig>>;
+
+  class Builder {
+   public:
+    /// Globally register a service config parser. Each new service config
+    /// update will go through all the registered parser. Each parser is
+    /// responsible for reading the service config json and returning a parsed
+    /// config.
+    void RegisterParser(std::unique_ptr<Parser> parser);
+
+    ServiceConfigParser Build();
+
+   private:
+    ServiceConfigParserList registered_parsers_;
+  };
+
+  ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
+                                           const Json& json,
+                                           grpc_error_handle* error) const;
+
+  ParsedConfigVector ParsePerMethodParameters(const grpc_channel_args* args,
+                                              const Json& json,
+                                              grpc_error_handle* error) const;
+
+  // Return the index for a given registered parser.
+  // If there is an error, return -1.
+  size_t GetParserIndex(absl::string_view name) const;
+
+ private:
+  explicit ServiceConfigParser(ServiceConfigParserList registered_parsers)
+      : registered_parsers_(std::move(registered_parsers)) {}
+  ServiceConfigParserList registered_parsers_;
 };
 
 }  // namespace grpc_core