grpc 1.27.0 → 1.28.0.pre2

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

@@ -109,10 +109,10 @@ class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig {
 class ClientChannelServiceConfigParser : public ServiceConfig::Parser {
  public:
   std::unique_ptr<ServiceConfig::ParsedConfig> ParseGlobalParams(
-      const grpc_json* json, grpc_error** error) override;
+      const Json& json, grpc_error** error) override;
 
   std::unique_ptr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
-      const grpc_json* json, grpc_error** error) override;
+      const Json& json, grpc_error** error) override;
 
   static size_t ParserIndex();
   static void Register();

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

@@ -188,7 +188,7 @@ ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
   GPR_ASSERT(process_resolver_result != nullptr);
   resolver_ = ResolverRegistry::CreateResolver(
       target_uri_.get(), args.args, interested_parties(), combiner(),
-      MakeUnique<ResolverResultHandler>(Ref()));
+      absl::make_unique<ResolverResultHandler>(Ref()));
   // Since the validity of args has been checked when create the channel,
   // CreateResolver() must return a non-null result.
   GPR_ASSERT(resolver_ != nullptr);
@@ -196,7 +196,7 @@ ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
     gpr_log(GPR_INFO, "resolving_lb=%p: starting name resolution", this);
   }
   channel_control_helper()->UpdateState(GRPC_CHANNEL_CONNECTING,
-                                        MakeUnique<QueuePicker>(Ref()));
+                                        absl::make_unique<QueuePicker>(Ref()));
   resolver_->StartLocked();
 }
 
@@ -262,13 +262,12 @@ void ResolvingLoadBalancingPolicy::OnResolverError(grpc_error* error) {
         "Resolver transient failure", &error, 1);
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE,
-        MakeUnique<TransientFailurePicker>(state_error));
+        absl::make_unique<TransientFailurePicker>(state_error));
   }
   GRPC_ERROR_UNREF(error);
 }
 
 void ResolvingLoadBalancingPolicy::CreateOrUpdateLbPolicyLocked(
-    const char* lb_policy_name,
     RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config,
     Resolver::Result result, TraceStringVector* trace_strings) {
   // If the child policy name changes, we need to create a new child
@@ -320,6 +319,7 @@ void ResolvingLoadBalancingPolicy::CreateOrUpdateLbPolicyLocked(
   //       that was there before, which will be immediately shut down)
   //       and will later be swapped into child_policy_ by the helper
   //       when the new child transitions into state READY.
+  const char* lb_policy_name = lb_policy_config->name();
   const bool create_policy =
       // case 1
       lb_policy_ == nullptr ||
@@ -451,34 +451,33 @@ void ResolvingLoadBalancingPolicy::OnResolverResultChangedLocked(
   TraceStringVector trace_strings;
   const bool resolution_contains_addresses = result.addresses.size() > 0;
   // Process the resolver result.
-  const char* lb_policy_name = nullptr;
   RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config;
   bool service_config_changed = false;
   char* service_config_error_string = nullptr;
   if (process_resolver_result_ != nullptr) {
     grpc_error* service_config_error = GRPC_ERROR_NONE;
+    bool no_valid_service_config = false;
     service_config_changed = process_resolver_result_(
-        process_resolver_result_user_data_, result, &lb_policy_name,
-        &lb_policy_config, &service_config_error);
+        process_resolver_result_user_data_, result, &lb_policy_config,
+        &service_config_error, &no_valid_service_config);
     if (service_config_error != GRPC_ERROR_NONE) {
       service_config_error_string =
           gpr_strdup(grpc_error_string(service_config_error));
-      if (lb_policy_name == nullptr) {
-        // Use an empty lb_policy_name as an indicator that we received an
-        // invalid service config and we don't have a fallback service config.
+      if (no_valid_service_config) {
+        // We received an invalid service config and we don't have a
+        // fallback service config.
         OnResolverError(service_config_error);
       } else {
         GRPC_ERROR_UNREF(service_config_error);
       }
     }
   } else {
-    lb_policy_name = child_policy_name_.get();
     lb_policy_config = child_lb_config_;
   }
-  if (lb_policy_name != nullptr) {
+  if (lb_policy_config != nullptr) {
     // Create or update LB policy, as needed.
-    CreateOrUpdateLbPolicyLocked(lb_policy_name, lb_policy_config,
-                                 std::move(result), &trace_strings);
+    CreateOrUpdateLbPolicyLocked(std::move(lb_policy_config), std::move(result),
+                                 &trace_strings);
   }
   // Add channel trace event.
   if (service_config_changed) {

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

@@ -52,16 +52,15 @@ namespace grpc_core {
 class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
  public:
   // Synchronous callback that takes the resolver result and sets
-  // lb_policy_name and lb_policy_config to point to the right data.
+  // lb_policy_config to point to the right data.
   // Returns true if the service config has changed since the last result.
-  // If the returned service_config_error is not none and lb_policy_name is
-  // empty, it means that we don't have a valid service config to use, and we
-  // should set the channel to be in TRANSIENT_FAILURE.
+  // If the returned no_valid_service_config is true, that means that we
+  // don't have a valid service config to use, and we should set the channel
+  // to be in TRANSIENT_FAILURE.
   typedef bool (*ProcessResolverResultCallback)(
       void* user_data, const Resolver::Result& result,
-      const char** lb_policy_name,
       RefCountedPtr<LoadBalancingPolicy::Config>* lb_policy_config,
-      grpc_error** service_config_error);
+      grpc_error** service_config_error, bool* no_valid_service_config);
   // If error is set when this returns, then construction failed, and
   // the caller may not use the new object.
   ResolvingLoadBalancingPolicy(
@@ -92,7 +91,6 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
 
   void OnResolverError(grpc_error* error);
   void CreateOrUpdateLbPolicyLocked(
-      const char* lb_policy_name,
       RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config,
       Resolver::Result result, TraceStringVector* trace_strings);
   OrphanablePtr<LoadBalancingPolicy> CreateLbPolicyLocked(

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

@@ -40,37 +40,29 @@ typedef InlinedVector<std::unique_ptr<ServiceConfig::Parser>,
 ServiceConfigParserList* g_registered_parsers;
 }  // namespace
 
-RefCountedPtr<ServiceConfig> ServiceConfig::Create(const char* json,
+RefCountedPtr<ServiceConfig> ServiceConfig::Create(StringView json_string,
                                                    grpc_error** error) {
-  grpc_core::UniquePtr<char> service_config_json(gpr_strdup(json));
-  grpc_core::UniquePtr<char> json_string(gpr_strdup(json));
   GPR_DEBUG_ASSERT(error != nullptr);
-  grpc_json* json_tree = grpc_json_parse_string(json_string.get());
-  if (json_tree == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "failed to parse JSON for service config");
-    return nullptr;
-  }
+  Json json = Json::Parse(json_string, error);
+  if (*error != GRPC_ERROR_NONE) return nullptr;
   return MakeRefCounted<ServiceConfig>(
-      std::move(service_config_json), std::move(json_string), json_tree, error);
+      std::string(json_string.data(), json_string.size()), std::move(json),
+      error);
 }
 
-ServiceConfig::ServiceConfig(grpc_core::UniquePtr<char> service_config_json,
-                             grpc_core::UniquePtr<char> json_string,
-                             grpc_json* json_tree, grpc_error** error)
-    : service_config_json_(std::move(service_config_json)),
-      json_string_(std::move(json_string)),
-      json_tree_(json_tree) {
+ServiceConfig::ServiceConfig(std::string json_string, Json json,
+                             grpc_error** error)
+    : json_string_(std::move(json_string)), json_(std::move(json)) {
   GPR_DEBUG_ASSERT(error != nullptr);
-  if (json_tree->type != GRPC_JSON_OBJECT || json_tree->key != nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Malformed service Config JSON object");
+  if (json_.type() != Json::Type::OBJECT) {
+    *error =
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
     return;
   }
   grpc_error* error_list[2];
   int error_count = 0;
-  grpc_error* global_error = ParseGlobalParams(json_tree);
-  grpc_error* local_error = ParsePerMethodParams(json_tree);
+  grpc_error* global_error = ParseGlobalParams();
+  grpc_error* local_error = ParsePerMethodParams();
   if (global_error != GRPC_ERROR_NONE) {
     error_list[error_count++] = global_error;
   }
@@ -85,14 +77,12 @@ ServiceConfig::ServiceConfig(grpc_core::UniquePtr<char> service_config_json,
   }
 }
 
-grpc_error* ServiceConfig::ParseGlobalParams(const grpc_json* json_tree) {
-  GPR_DEBUG_ASSERT(json_tree_->type == GRPC_JSON_OBJECT);
-  GPR_DEBUG_ASSERT(json_tree_->key == nullptr);
-  InlinedVector<grpc_error*, 4> error_list;
+grpc_error* ServiceConfig::ParseGlobalParams() {
+  std::vector<grpc_error*> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
     grpc_error* parser_error = GRPC_ERROR_NONE;
     auto parsed_obj =
-        (*g_registered_parsers)[i]->ParseGlobalParams(json_tree, &parser_error);
+        (*g_registered_parsers)[i]->ParseGlobalParams(json_, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
       error_list.push_back(parser_error);
     }
@@ -102,9 +92,10 @@ grpc_error* ServiceConfig::ParseGlobalParams(const grpc_json* json_tree) {
 }
 
 grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable(
-    const grpc_json* json,
-    SliceHashTable<const ParsedConfigVector*>::Entry* entries, size_t* idx) {
-  auto objs_vector = MakeUnique<ParsedConfigVector>();
+    const Json& json,
+    InlinedVector<SliceHashTable<const ParsedConfigVector*>::Entry, 10>*
+        entries) {
+  auto objs_vector = absl::make_unique<ParsedConfigVector>();
   InlinedVector<grpc_error*, 4> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
     grpc_error* parser_error = GRPC_ERROR_NONE;
@@ -116,30 +107,25 @@ grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable(
     objs_vector->push_back(std::move(parsed_obj));
   }
   parsed_method_config_vectors_storage_.push_back(std::move(objs_vector));
-  const auto* vector_ptr =
-      parsed_method_config_vectors_storage_
-          [parsed_method_config_vectors_storage_.size() - 1]
-              .get();
+  const auto* vector_ptr = parsed_method_config_vectors_storage_.back().get();
   // Construct list of paths.
-  InlinedVector<grpc_core::UniquePtr<char>, 10> paths;
-  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) continue;
-    if (strcmp(child->key, "name") == 0) {
-      if (child->type != GRPC_JSON_ARRAY) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:name error:not of type Array"));
-        goto wrap_error;
-      }
-      for (grpc_json* name = child->child; name != nullptr; name = name->next) {
-        grpc_error* parse_error = GRPC_ERROR_NONE;
-        grpc_core::UniquePtr<char> path =
-            ParseJsonMethodName(name, &parse_error);
-        if (path == nullptr) {
-          error_list.push_back(parse_error);
-        } else {
-          GPR_DEBUG_ASSERT(parse_error == GRPC_ERROR_NONE);
-          paths.push_back(std::move(path));
-        }
+  InlinedVector<UniquePtr<char>, 10> paths;
+  auto it = json.object_value().find("name");
+  if (it != json.object_value().end()) {
+    if (it->second.type() != Json::Type::ARRAY) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:name error:not of type Array"));
+      return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
+    }
+    const Json::Array& name_array = it->second.array_value();
+    for (const Json& name : name_array) {
+      grpc_error* parse_error = GRPC_ERROR_NONE;
+      UniquePtr<char> path = ParseJsonMethodName(name, &parse_error);
+      if (path == nullptr) {
+        error_list.push_back(parse_error);
+      } else {
+        GPR_DEBUG_ASSERT(parse_error == GRPC_ERROR_NONE);
+        paths.push_back(std::move(path));
       }
     }
   }
@@ -149,140 +135,86 @@ grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable(
   }
   // Add entry for each path.
   for (size_t i = 0; i < paths.size(); ++i) {
-    entries[*idx].key = grpc_slice_from_copied_string(paths[i].get());
-    entries[*idx].value = vector_ptr;
-    ++*idx;
+    entries->push_back(
+        {grpc_slice_from_copied_string(paths[i].get()), vector_ptr});
   }
-wrap_error:
   return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
 }
 
-grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_json* json_tree) {
-  GPR_DEBUG_ASSERT(json_tree_->type == GRPC_JSON_OBJECT);
-  GPR_DEBUG_ASSERT(json_tree_->key == nullptr);
-  SliceHashTable<const ParsedConfigVector*>::Entry* entries = nullptr;
-  size_t num_entries = 0;
-  InlinedVector<grpc_error*, 4> error_list;
-  for (grpc_json* field = json_tree->child; field != nullptr;
-       field = field->next) {
-    if (field->key == nullptr) {
+grpc_error* ServiceConfig::ParsePerMethodParams() {
+  InlinedVector<SliceHashTable<const ParsedConfigVector*>::Entry, 10> entries;
+  std::vector<grpc_error*> error_list;
+  auto it = json_.object_value().find("methodConfig");
+  if (it != json_.object_value().end()) {
+    if (it->second.type() != Json::Type::ARRAY) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "error:Illegal key value - NULL"));
-      continue;
+          "field:methodConfig error:not of type Array"));
     }
-    if (strcmp(field->key, "methodConfig") == 0) {
-      if (entries != nullptr) {
-        GPR_ASSERT(false);
-      }
-      if (field->type != GRPC_JSON_ARRAY) {
+    for (const Json& method_config : it->second.array_value()) {
+      if (method_config.type() != Json::Type::OBJECT) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:methodConfig error:not of type Array"));
-      }
-      for (grpc_json* method = field->child; method != nullptr;
-           method = method->next) {
-        int count = CountNamesInMethodConfig(method);
-        if (count <= 0) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:methodConfig error:No names found"));
-        }
-        num_entries += static_cast<size_t>(count);
+            "field:methodConfig error:not of type Object"));
+        continue;
       }
-      entries = static_cast<SliceHashTable<const ParsedConfigVector*>::Entry*>(
-          gpr_zalloc(num_entries *
-                     sizeof(SliceHashTable<const ParsedConfigVector*>::Entry)));
-      size_t idx = 0;
-      for (grpc_json* method = field->child; method != nullptr;
-           method = method->next) {
-        grpc_error* error = ParseJsonMethodConfigToServiceConfigVectorTable(
-            method, entries, &idx);
-        if (error != GRPC_ERROR_NONE) {
-          error_list.push_back(error);
-        }
+      grpc_error* error = ParseJsonMethodConfigToServiceConfigVectorTable(
+          method_config, &entries);
+      if (error != GRPC_ERROR_NONE) {
+        error_list.push_back(error);
       }
-      // idx might not be equal to num_entries due to parsing errors
-      num_entries = idx;
-      break;
     }
   }
-  if (entries != nullptr) {
+  if (!entries.empty()) {
     parsed_method_configs_table_ =
-        SliceHashTable<const ParsedConfigVector*>::Create(num_entries, entries,
-                                                          nullptr);
-    gpr_free(entries);
+        SliceHashTable<const ParsedConfigVector*>::Create(
+            entries.size(), entries.data(), nullptr);
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("Method Params", &error_list);
 }
 
-ServiceConfig::~ServiceConfig() { grpc_json_destroy(json_tree_); }
-
-int ServiceConfig::CountNamesInMethodConfig(grpc_json* json) {
-  int num_names = 0;
-  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
-    if (field->key != nullptr && strcmp(field->key, "name") == 0) {
-      if (field->type != GRPC_JSON_ARRAY) return -1;
-      for (grpc_json* name = field->child; name != nullptr; name = name->next) {
-        if (name->type != GRPC_JSON_OBJECT) return -1;
-        ++num_names;
-      }
-    }
-  }
-  return num_names;
-}
-
-grpc_core::UniquePtr<char> ServiceConfig::ParseJsonMethodName(
-    grpc_json* json, grpc_error** error) {
-  if (json->type != GRPC_JSON_OBJECT) {
+UniquePtr<char> ServiceConfig::ParseJsonMethodName(const Json& json,
+                                                   grpc_error** error) {
+  if (json.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:name error:type is not object");
     return nullptr;
   }
-  const char* service_name = nullptr;
+  // Find service name.
+  auto it = json.object_value().find("service");
+  if (it == json.object_value().end()) {
+    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:name error: field:service error:not found");
+    return nullptr;  // Required field.
+  }
+  if (it->second.type() != Json::Type::STRING) {
+    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:name error: field:service error:not of type string");
+    return nullptr;
+  }
+  if (it->second.string_value().empty()) {
+    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:name error: field:service error:empty value");
+    return nullptr;
+  }
+  const char* service_name = it->second.string_value().c_str();
   const char* method_name = nullptr;
-  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
-    if (child->key == nullptr) {
+  // Find method name.
+  it = json.object_value().find("method");
+  if (it != json.object_value().end()) {
+    if (it->second.type() != Json::Type::STRING) {
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:name error:Child entry with no key");
+          "field:name error: field:method error:not of type string");
       return nullptr;
     }
-    if (child->type != GRPC_JSON_STRING) {
+    if (it->second.string_value().empty()) {
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:name error:Child entry not of type string");
+          "field:name error: field:method error:empty value");
       return nullptr;
     }
-    if (strcmp(child->key, "service") == 0) {
-      if (service_name != nullptr) {
-        *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:name error: field:service error:Multiple entries");
-        return nullptr;  // Duplicate.
-      }
-      if (child->value == nullptr) {
-        *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:name error: field:service error:empty value");
-        return nullptr;
-      }
-      service_name = child->value;
-    } else if (strcmp(child->key, "method") == 0) {
-      if (method_name != nullptr) {
-        *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:name error: field:method error:multiple entries");
-        return nullptr;  // Duplicate.
-      }
-      if (child->value == nullptr) {
-        *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:name error: field:method error:empty value");
-        return nullptr;
-      }
-      method_name = child->value;
-    }
-  }
-  if (service_name == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:name error: field:service error:not found");
-    return nullptr;  // Required field.
+    method_name = it->second.string_value().c_str();
   }
   char* path;
   gpr_asprintf(&path, "/%s/%s", service_name,
-               method_name == nullptr ? "*" : method_name);
+               method_name == nullptr ? "" : method_name);
   return grpc_core::UniquePtr<char>(path);
 }
 
@@ -293,15 +225,14 @@ ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) {
   }
   const auto* value = parsed_method_configs_table_->Get(path);
   // If we didn't find a match for the path, try looking for a wildcard
-  // entry (i.e., change "/service/method" to "/service/*").
+  // entry (i.e., change "/service/method" to "/service/").
   if (value == nullptr) {
     char* path_str = grpc_slice_to_c_string(path);
     const char* sep = strrchr(path_str, '/') + 1;
     const size_t len = (size_t)(sep - path_str);
-    char* buf = (char*)gpr_malloc(len + 2);  // '*' and NUL
+    char* buf = (char*)gpr_malloc(len + 1);  // trailing NUL
     memcpy(buf, path_str, len);
-    buf[len] = '*';
-    buf[len + 1] = '\0';
+    buf[len] = '\0';
     grpc_slice wildcard_path = grpc_slice_from_copied_string(buf);
     gpr_free(buf);
     value = parsed_method_configs_table_->Get(wildcard_path);