grpc 1.27.0 → 1.30.2

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

@@ -28,6 +28,8 @@ namespace grpc_core {
 
 class LoadBalancingPolicyFactory {
  public:
+  virtual ~LoadBalancingPolicyFactory() {}
+
   /// Returns a new LB policy instance.
   virtual OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args) const = 0;
@@ -37,9 +39,7 @@ class LoadBalancingPolicyFactory {
   virtual const char* name() const = 0;
 
   virtual RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** error) const = 0;
-
-  virtual ~LoadBalancingPolicyFactory() {}
+      const Json& json, grpc_error** error) const = 0;
 };
 
 }  // namespace grpc_core

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

@@ -22,8 +22,9 @@
 
 #include <string.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 
 namespace grpc_core {
 
@@ -35,6 +36,8 @@ class RegistryState {
 
   void RegisterLoadBalancingPolicyFactory(
       std::unique_ptr<LoadBalancingPolicyFactory> factory) {
+    gpr_log(GPR_DEBUG, "registering LB policy factory for \"%s\"",
+            factory->name());
     for (size_t i = 0; i < factories_.size(); ++i) {
       GPR_ASSERT(strcmp(factories_[i]->name(), factory->name()) != 0);
     }
@@ -52,7 +55,8 @@ class RegistryState {
   }
 
  private:
-  InlinedVector<std::unique_ptr<LoadBalancingPolicyFactory>, 10> factories_;
+  absl::InlinedVector<std::unique_ptr<LoadBalancingPolicyFactory>, 10>
+      factories_;
 };
 
 RegistryState* g_state = nullptr;
@@ -105,106 +109,74 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
     grpc_error* error = GRPC_ERROR_NONE;
     // Check if the load balancing policy allows an empty config
     *requires_config =
-        factory->ParseLoadBalancingConfig(nullptr, &error) == nullptr;
+        factory->ParseLoadBalancingConfig(Json(), &error) == nullptr;
     GRPC_ERROR_UNREF(error);
   }
   return true;
 }
 
 namespace {
+
 // Returns the JSON node of policy (with both policy name and config content)
 // given the JSON node of a LoadBalancingConfig array.
-grpc_json* ParseLoadBalancingConfigHelper(const grpc_json* lb_config_array,
-                                          grpc_error** error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  if (lb_config_array == nullptr) {
-    *error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("LB config JSON tree is null");
-    return nullptr;
+grpc_error* ParseLoadBalancingConfigHelper(
+    const Json& lb_config_array, Json::Object::const_iterator* result) {
+  if (lb_config_array.type() != Json::Type::ARRAY) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("type should be array");
   }
-  char* error_msg;
-  if (lb_config_array->type != GRPC_JSON_ARRAY) {
-    gpr_asprintf(&error_msg, "field:%s error:type should be array",
-                 lb_config_array->key);
-    *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-    gpr_free(error_msg);
-    return nullptr;
-  }
-  const char* field_name = lb_config_array->key;
   // Find the first LB policy that this client supports.
-  for (const grpc_json* lb_config = lb_config_array->child;
-       lb_config != nullptr; lb_config = lb_config->next) {
-    if (lb_config->type != GRPC_JSON_OBJECT) {
-      gpr_asprintf(&error_msg,
-                   "field:%s error:child entry should be of type object",
-                   field_name);
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-      gpr_free(error_msg);
-      return nullptr;
+  for (const Json& lb_config : lb_config_array.array_value()) {
+    if (lb_config.type() != Json::Type::OBJECT) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "child entry should be of type object");
     }
-    grpc_json* policy = nullptr;
-    for (grpc_json* field = lb_config->child; field != nullptr;
-         field = field->next) {
-      if (field->key == nullptr || field->type != GRPC_JSON_OBJECT) {
-        gpr_asprintf(&error_msg,
-                     "field:%s error:child entry should be of type object",
-                     field_name);
-        *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-        gpr_free(error_msg);
-        return nullptr;
-      }
-      if (policy != nullptr) {
-        gpr_asprintf(&error_msg, "field:%s error:oneOf violation", field_name);
-        *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-        gpr_free(error_msg);
-        return nullptr;
-      }  // Violate "oneof" type.
-      policy = field;
+    if (lb_config.object_value().empty()) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "no policy found in child entry");
+    }
+    if (lb_config.object_value().size() > 1) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("oneOf violation");
     }
-    if (policy == nullptr) {
-      gpr_asprintf(&error_msg, "field:%s error:no policy found in child entry",
-                   field_name);
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-      gpr_free(error_msg);
-      return nullptr;
+    auto it = lb_config.object_value().begin();
+    if (it->second.type() != Json::Type::OBJECT) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "child entry should be of type object");
     }
     // If we support this policy, then select it.
-    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(policy->key,
-                                                               nullptr)) {
-      return policy;
+    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
+            it->first.c_str(), nullptr)) {
+      *result = it;
+      return GRPC_ERROR_NONE;
     }
   }
-  gpr_asprintf(&error_msg, "field:%s error:No known policy", field_name);
-  *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-  gpr_free(error_msg);
-  return nullptr;
+  return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No known policy");
 }
+
 }  // namespace
 
 RefCountedPtr<LoadBalancingPolicy::Config>
-LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const grpc_json* json,
+LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const Json& json,
                                                       grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   GPR_ASSERT(g_state != nullptr);
-  const grpc_json* policy = ParseLoadBalancingConfigHelper(json, error);
-  if (policy == nullptr) {
+  Json::Object::const_iterator policy;
+  *error = ParseLoadBalancingConfigHelper(json, &policy);
+  if (*error != GRPC_ERROR_NONE) {
+    return nullptr;
+  }
+  // Find factory.
+  LoadBalancingPolicyFactory* factory =
+      g_state->GetLoadBalancingPolicyFactory(policy->first.c_str());
+  if (factory == nullptr) {
+    char* msg;
+    gpr_asprintf(&msg, "Factory not found for policy \"%s\"",
+                 policy->first.c_str());
+    *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+    gpr_free(msg);
     return nullptr;
-  } else {
-    GPR_DEBUG_ASSERT(*error == GRPC_ERROR_NONE && json != nullptr);
-    // Find factory.
-    LoadBalancingPolicyFactory* factory =
-        g_state->GetLoadBalancingPolicyFactory(policy->key);
-    if (factory == nullptr) {
-      char* msg;
-      gpr_asprintf(&msg, "field:%s error:Factory not found to create policy",
-                   json->key);
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
-      return nullptr;
-    }
-    // Parse load balancing config via factory.
-    return factory->ParseLoadBalancingConfig(policy, error);
   }
+  // Parse load balancing config via factory.
+  return factory->ParseLoadBalancingConfig(policy->second, error);
 }
 
 }  // namespace grpc_core

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

@@ -57,7 +57,7 @@ class LoadBalancingPolicyRegistry {
   /// Returns a parsed object of the load balancing policy to be used from a
   /// LoadBalancingConfig array \a json.
   static RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** error);
+      const Json& json, grpc_error** error);
 };
 
 }  // namespace grpc_core

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

@@ -38,7 +38,8 @@ class LocalSubchannelPool final : public SubchannelPoolInterface {
   ~LocalSubchannelPool() override;
 
   // Implements interface methods.
-  // Thread-unsafe. Intended to be invoked within the client_channel combiner.
+  // Thread-unsafe. Intended to be invoked within the client_channel work
+  // serializer.
   Subchannel* RegisterSubchannel(SubchannelKey* key,
                                  Subchannel* constructed) override;
   void UnregisterSubchannel(SubchannelKey* key) override;

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

@@ -73,8 +73,8 @@ bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
                               bool log_errors) {
   bool success = false;
   // Split host and port.
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
+  std::string host;
+  std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
       gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
@@ -86,21 +86,21 @@ bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
   addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
   grpc_sockaddr_in* in = reinterpret_cast<grpc_sockaddr_in*>(addr->addr);
   in->sin_family = GRPC_AF_INET;
-  if (grpc_inet_pton(GRPC_AF_INET, host.get(), &in->sin_addr) == 0) {
+  if (grpc_inet_pton(GRPC_AF_INET, host.c_str(), &in->sin_addr) == 0) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host.get());
+      gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host.c_str());
     }
     goto done;
   }
   // Parse port.
-  if (port == nullptr) {
+  if (port.empty()) {
     if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
     goto done;
   }
   int port_num;
-  if (sscanf(port.get(), "%d", &port_num) != 1 || port_num < 0 ||
+  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
       port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port.get());
+    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port.c_str());
     goto done;
   }
   in->sin_port = grpc_htons(static_cast<uint16_t>(port_num));
@@ -125,8 +125,8 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
                               bool log_errors) {
   bool success = false;
   // Split host and port.
-  grpc_core::UniquePtr<char> host;
-  grpc_core::UniquePtr<char> port;
+  std::string host;
+  std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
       gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
@@ -140,11 +140,12 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
   in6->sin6_family = GRPC_AF_INET6;
   // Handle the RFC6874 syntax for IPv6 zone identifiers.
   char* host_end =
-      static_cast<char*>(gpr_memrchr(host.get(), '%', strlen(host.get())));
+      static_cast<char*>(gpr_memrchr(host.c_str(), '%', host.size()));
   if (host_end != nullptr) {
-    GPR_ASSERT(host_end >= host.get());
+    GPR_ASSERT(host_end >= host.c_str());
     char host_without_scope[GRPC_INET6_ADDRSTRLEN + 1];
-    size_t host_without_scope_len = static_cast<size_t>(host_end - host.get());
+    size_t host_without_scope_len =
+        static_cast<size_t>(host_end - host.c_str());
     uint32_t sin6_scope_id = 0;
     if (host_without_scope_len > GRPC_INET6_ADDRSTRLEN) {
       if (log_errors) {
@@ -156,7 +157,7 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
       }
       goto done;
     }
-    strncpy(host_without_scope, host.get(), host_without_scope_len);
+    strncpy(host_without_scope, host.c_str(), host_without_scope_len);
     host_without_scope[host_without_scope_len] = '\0';
     if (grpc_inet_pton(GRPC_AF_INET6, host_without_scope, &in6->sin6_addr) ==
         0) {
@@ -165,9 +166,9 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
       }
       goto done;
     }
-    if (gpr_parse_bytes_to_uint32(
-            host_end + 1, strlen(host.get()) - host_without_scope_len - 1,
-            &sin6_scope_id) == 0) {
+    if (gpr_parse_bytes_to_uint32(host_end + 1,
+                                  host.size() - host_without_scope_len - 1,
+                                  &sin6_scope_id) == 0) {
       if ((sin6_scope_id = grpc_if_nametoindex(host_end + 1)) == 0) {
         gpr_log(GPR_ERROR,
                 "Invalid interface name: '%s'. "
@@ -179,22 +180,22 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
     // Handle "sin6_scope_id" being type "u_long". See grpc issue #10027.
     in6->sin6_scope_id = sin6_scope_id;
   } else {
-    if (grpc_inet_pton(GRPC_AF_INET6, host.get(), &in6->sin6_addr) == 0) {
+    if (grpc_inet_pton(GRPC_AF_INET6, host.c_str(), &in6->sin6_addr) == 0) {
       if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host.get());
+        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host.c_str());
       }
       goto done;
     }
   }
   // Parse port.
-  if (port == nullptr) {
+  if (port.empty()) {
     if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
     goto done;
   }
   int port_num;
-  if (sscanf(port.get(), "%d", &port_num) != 1 || port_num < 0 ||
+  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
       port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port.get());
+    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port.c_str());
     goto done;
   }
   in6->sin6_port = grpc_htons(static_cast<uint16_t>(port_num));

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

@@ -19,7 +19,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/resolver.h"
-#include "src/core/lib/iomgr/combiner.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
                                                            "resolver_refcount");
@@ -30,13 +29,11 @@ namespace grpc_core {
 // Resolver
 //
 
-Resolver::Resolver(Combiner* combiner,
+Resolver::Resolver(std::shared_ptr<WorkSerializer> work_serializer,
                    std::unique_ptr<ResultHandler> result_handler)
     : InternallyRefCounted(&grpc_trace_resolver_refcount),
-      result_handler_(std::move(result_handler)),
-      combiner_(GRPC_COMBINER_REF(combiner, "resolver")) {}
-
-Resolver::~Resolver() { GRPC_COMBINER_UNREF(combiner_, "resolver"); }
+      work_serializer_(std::move(work_serializer)),
+      result_handler_(std::move(result_handler)) {}
 
 //
 // Resolver::Result
@@ -54,7 +51,7 @@ Resolver::Result::Result(const Result& other) {
   args = grpc_channel_args_copy(other.args);
 }
 
-Resolver::Result::Result(Result&& other) {
+Resolver::Result::Result(Result&& other) noexcept {
   addresses = std::move(other.addresses);
   service_config = std::move(other.service_config);
   service_config_error = other.service_config_error;
@@ -73,7 +70,7 @@ Resolver::Result& Resolver::Result::operator=(const Result& other) {
   return *this;
 }
 
-Resolver::Result& Resolver::Result::operator=(Result&& other) {
+Resolver::Result& Resolver::Result::operator=(Result&& other) noexcept {
   addresses = std::move(other.addresses);
   service_config = std::move(other.service_config);
   GRPC_ERROR_UNREF(service_config_error);

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

@@ -27,8 +27,8 @@
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
 
@@ -45,7 +45,7 @@ namespace grpc_core {
 /// DNS).
 ///
 /// Note: All methods with a "Locked" suffix must be called from the
-/// combiner passed to the constructor.
+/// work_serializer passed to the constructor.
 class Resolver : public InternallyRefCounted<Resolver> {
  public:
   /// Results returned by the resolver.
@@ -60,9 +60,9 @@ class Resolver : public InternallyRefCounted {
     Result() = default;
     ~Result();
     Result(const Result& other);
-    Result(Result&& other);
+    Result(Result&& other) noexcept;
     Result& operator=(const Result& other);
-    Result& operator=(Result&& other);
+    Result& operator=(Result&& other) noexcept;
   };
 
   /// A proxy object used by the resolver to return results to the
@@ -87,7 +87,7 @@ class Resolver : public InternallyRefCounted {
   // Not copyable nor movable.
   Resolver(const Resolver&) = delete;
   Resolver& operator=(const Resolver&) = delete;
-  virtual ~Resolver();
+  virtual ~Resolver() = default;
 
   /// Starts resolving.
   virtual void StartLocked() = 0;
@@ -115,30 +115,28 @@ class Resolver : public InternallyRefCounted {
   /// implementations.  At that point, this method can go away.
   virtual void ResetBackoffLocked() {}
 
-  // Note: This must be invoked while holding the combiner.
+  // Note: This must be invoked while holding the work_serializer.
   void Orphan() override {
     ShutdownLocked();
     Unref();
   }
 
  protected:
-  /// Does NOT take ownership of the reference to \a combiner.
-  // TODO(roth): Once we have a C++-like interface for combiners, this
-  // API should change to take a RefCountedPtr<>, so that we always take
-  // ownership of a new ref.
-  explicit Resolver(Combiner* combiner,
-                    std::unique_ptr<ResultHandler> result_handler);
+  Resolver(std::shared_ptr<WorkSerializer> work_serializer,
+           std::unique_ptr<ResultHandler> result_handler);
 
   /// Shuts down the resolver.
   virtual void ShutdownLocked() = 0;
 
-  Combiner* combiner() const { return combiner_; }
+  std::shared_ptr<WorkSerializer> work_serializer() const {
+    return work_serializer_;
+  }
 
   ResultHandler* result_handler() const { return result_handler_.get(); }
 
  private:
+  std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
-  Combiner* combiner_;
 };
 
 }  // namespace grpc_core