grpc 1.18.0 → 1.19.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/xds/xds.cc

@@ -80,7 +80,6 @@
 #include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/ext/filters/client_channel/subchannel_index.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -101,6 +100,7 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/transport/service_config.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 #define GRPC_XDS_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -119,7 +119,7 @@ constexpr char kXds[] = "xds_experimental";
 
 class XdsLb : public LoadBalancingPolicy {
  public:
-  explicit XdsLb(const Args& args);
+  explicit XdsLb(Args args);
 
   const char* name() const override { return kXds; }
 
@@ -248,6 +248,12 @@ class XdsLb : public LoadBalancingPolicy {
   // Helper function used in ctor and UpdateLocked().
   void ProcessChannelArgsLocked(const grpc_channel_args& args);
 
+  // Parses the xds config given the JSON node of the first child of XdsConfig.
+  // If parsing succeeds, updates \a balancer_name, and updates \a
+  // child_policy_json_dump_ and \a fallback_policy_json_dump_ if they are also
+  // found. Does nothing upon failure.
+  void ParseLbConfig(grpc_json* xds_config_json);
+
   // Methods for dealing with the balancer channel and call.
   void StartPickingLocked();
   void StartBalancerCallLocked();
@@ -266,7 +272,7 @@ class XdsLb : public LoadBalancingPolicy {
   // Methods for dealing with the child policy.
   void CreateOrUpdateChildPolicyLocked();
   grpc_channel_args* CreateChildPolicyArgsLocked();
-  void CreateChildPolicyLocked(const Args& args);
+  void CreateChildPolicyLocked(const char* name, Args args);
   bool PickFromChildPolicyLocked(bool force_async, PendingPick* pp,
                                  grpc_error** error);
   void UpdateConnectivityStateFromChildPolicyLocked(
@@ -279,6 +285,9 @@ class XdsLb : public LoadBalancingPolicy {
   // Who the client is trying to communicate with.
   const char* server_name_ = nullptr;
 
+  // Name of the balancer to connect to.
+  UniquePtr<char> balancer_name_;
+
   // Current channel args from the resolver.
   grpc_channel_args* args_ = nullptr;
 
@@ -319,6 +328,7 @@ class XdsLb : public LoadBalancingPolicy {
 
   // Timeout in milliseconds for before using fallback backend addresses.
   // 0 means not using fallback.
+  UniquePtr<char> fallback_policy_json_string_;
   int lb_fallback_timeout_ms_ = 0;
   // The backend addresses from the resolver.
   UniquePtr<ServerAddressList> fallback_backend_addresses_;
@@ -332,6 +342,7 @@ class XdsLb : public LoadBalancingPolicy {
 
   // The policy to use for the backends.
   OrphanablePtr<LoadBalancingPolicy> child_policy_;
+  UniquePtr<char> child_policy_json_string_;
   grpc_connectivity_state child_connectivity_state_;
   grpc_closure on_child_connectivity_changed_;
   grpc_closure on_child_request_reresolution_;
@@ -893,8 +904,8 @@ grpc_channel_args* BuildBalancerChannelArgs(
 //
 
 // TODO(vishalpowar): Use lb_config in args to configure LB policy.
-XdsLb::XdsLb(const LoadBalancingPolicy::Args& args)
-    : LoadBalancingPolicy(args),
+XdsLb::XdsLb(LoadBalancingPolicy::Args args)
+    : LoadBalancingPolicy(std::move(args)),
       response_generator_(MakeRefCounted<FakeResolverResponseGenerator>()),
       lb_call_backoff_(
           BackOff::Options()
@@ -905,7 +916,6 @@ XdsLb::XdsLb(const LoadBalancingPolicy::Args& args)
               .set_max_backoff(GRPC_XDS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)) {
   // Initialization.
   gpr_mu_init(&lb_channel_mu_);
-  grpc_subchannel_index_ref();
   GRPC_CLOSURE_INIT(&lb_channel_on_connectivity_changed_,
                     &XdsLb::OnBalancerChannelConnectivityChangedLocked, this,
                     grpc_combiner_scheduler(args.combiner));
@@ -936,6 +946,8 @@ XdsLb::XdsLb(const LoadBalancingPolicy::Args& args)
   arg = grpc_channel_args_find(args.args, GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS);
   lb_fallback_timeout_ms_ = grpc_channel_arg_get_integer(
       arg, {GRPC_XDS_DEFAULT_FALLBACK_TIMEOUT_MS, 0, INT_MAX});
+  // Parse the LB config.
+  ParseLbConfig(args.lb_config);
   // Process channel args.
   ProcessChannelArgsLocked(*args.args);
 }
@@ -949,7 +961,6 @@ XdsLb::~XdsLb() {
   if (serverlist_ != nullptr) {
     xds_grpclb_destroy_serverlist(serverlist_);
   }
-  grpc_subchannel_index_unref();
 }
 
 void XdsLb::ShutdownLocked() {
@@ -1187,8 +1198,44 @@ void XdsLb::ProcessChannelArgsLocked(const grpc_channel_args& args) {
   grpc_channel_args_destroy(lb_channel_args);
 }
 
-// TODO(vishalpowar): Use lb_config to configure LB policy.
+void XdsLb::ParseLbConfig(grpc_json* xds_config_json) {
+  const char* balancer_name = nullptr;
+  grpc_json* child_policy = nullptr;
+  grpc_json* fallback_policy = nullptr;
+  for (grpc_json* field = xds_config_json; field != nullptr;
+       field = field->next) {
+    if (field->key == nullptr) return;
+    if (strcmp(field->key, "balancerName") == 0) {
+      if (balancer_name != nullptr) return;  // Duplicate.
+      if (field->type != GRPC_JSON_STRING) return;
+      balancer_name = field->value;
+    } else if (strcmp(field->key, "childPolicy") == 0) {
+      if (child_policy != nullptr) return;  // Duplicate.
+      child_policy = ParseLoadBalancingConfig(field);
+    } else if (strcmp(field->key, "fallbackPolicy") == 0) {
+      if (fallback_policy != nullptr) return;  // Duplicate.
+      fallback_policy = ParseLoadBalancingConfig(field);
+    }
+  }
+  if (balancer_name == nullptr) return;  // Required field.
+  if (child_policy != nullptr) {
+    child_policy_json_string_ =
+        UniquePtr<char>(grpc_json_dump_to_string(child_policy, 0 /* indent */));
+  }
+  if (fallback_policy != nullptr) {
+    fallback_policy_json_string_ = UniquePtr<char>(
+        grpc_json_dump_to_string(fallback_policy, 0 /* indent */));
+  }
+  balancer_name_ = UniquePtr<char>(gpr_strdup(balancer_name));
+}
+
 void XdsLb::UpdateLocked(const grpc_channel_args& args, grpc_json* lb_config) {
+  ParseLbConfig(lb_config);
+  // TODO(juanlishen): Pass fallback policy config update after fallback policy
+  // is added.
+  if (balancer_name_ == nullptr) {
+    gpr_log(GPR_ERROR, "[xdslb %p] LB config parsing fails.", this);
+  }
   ProcessChannelArgsLocked(args);
   // Update the existing child policy.
   // Note: We have disabled fallback mode in the code, so this child policy must
@@ -1439,10 +1486,10 @@ bool XdsLb::PickFromChildPolicyLocked(bool force_async, PendingPick* pp,
   return pick_done;
 }
 
-void XdsLb::CreateChildPolicyLocked(const Args& args) {
+void XdsLb::CreateChildPolicyLocked(const char* name, Args args) {
   GPR_ASSERT(child_policy_ == nullptr);
   child_policy_ = LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-      "round_robin", args);
+      name, std::move(args));
   if (GPR_UNLIKELY(child_policy_ == nullptr)) {
     gpr_log(GPR_ERROR, "[xdslb %p] Failure creating a child policy", this);
     return;
@@ -1515,25 +1562,43 @@ void XdsLb::CreateOrUpdateChildPolicyLocked() {
   if (shutting_down_) return;
   grpc_channel_args* args = CreateChildPolicyArgsLocked();
   GPR_ASSERT(args != nullptr);
+  const char* child_policy_name = nullptr;
+  grpc_json* child_policy_config = nullptr;
+  grpc_json* child_policy_json =
+      grpc_json_parse_string(child_policy_json_string_.get());
+  // TODO(juanlishen): If the child policy is not configured via service config,
+  // use whatever algorithm is specified by the balancer.
+  if (child_policy_json != nullptr) {
+    child_policy_name = child_policy_json->key;
+    child_policy_config = child_policy_json->child;
+  } else {
+    if (grpc_lb_xds_trace.enabled()) {
+      gpr_log(GPR_INFO, "[xdslb %p] No valid child policy LB config", this);
+    }
+    child_policy_name = "round_robin";
+  }
+  // TODO(juanlishen): Switch policy according to child_policy_config->key.
   if (child_policy_ != nullptr) {
     if (grpc_lb_xds_trace.enabled()) {
       gpr_log(GPR_INFO, "[xdslb %p] Updating the child policy %p", this,
               child_policy_.get());
     }
-    // TODO(vishalpowar): Pass the correct LB config.
-    child_policy_->UpdateLocked(*args, nullptr);
+    child_policy_->UpdateLocked(*args, child_policy_config);
   } else {
     LoadBalancingPolicy::Args lb_policy_args;
     lb_policy_args.combiner = combiner();
     lb_policy_args.client_channel_factory = client_channel_factory();
+    lb_policy_args.subchannel_pool = subchannel_pool()->Ref();
     lb_policy_args.args = args;
-    CreateChildPolicyLocked(lb_policy_args);
+    lb_policy_args.lb_config = child_policy_config;
+    CreateChildPolicyLocked(child_policy_name, std::move(lb_policy_args));
     if (grpc_lb_xds_trace.enabled()) {
       gpr_log(GPR_INFO, "[xdslb %p] Created a new child policy %p", this,
               child_policy_.get());
     }
   }
   grpc_channel_args_destroy(args);
+  grpc_json_destroy(child_policy_json);
 }
 
 void XdsLb::OnChildPolicyRequestReresolutionLocked(void* arg,
@@ -1639,7 +1704,7 @@ void XdsLb::OnChildPolicyConnectivityChangedLocked(void* arg,
 class XdsFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
-      const LoadBalancingPolicy::Args& args) const override {
+      LoadBalancingPolicy::Args args) const override {
     /* Count the number of gRPC-LB addresses. There must be at least one. */
     const ServerAddressList* addresses =
         FindServerAddressListChannelArg(args.args);
@@ -1652,7 +1717,7 @@ class XdsFactory : public LoadBalancingPolicyFactory {
       }
     }
     if (!found_balancer_address) return nullptr;
-    return OrphanablePtr<LoadBalancingPolicy>(New<XdsLb>(args));
+    return OrphanablePtr<LoadBalancingPolicy>(New<XdsLb>(std::move(args)));
   }
 
   const char* name() const override { return kXds; }

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

@@ -31,7 +31,12 @@ class LoadBalancingPolicyFactory {
  public:
   /// Returns a new LB policy instance.
   virtual OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
-      const LoadBalancingPolicy::Args& args) const GRPC_ABSTRACT;
+      LoadBalancingPolicy::Args args) const {
+    std::move(args);  // Suppress clang-tidy complaint.
+    // The rest of this is copied from the GRPC_ABSTRACT macro.
+    gpr_log(GPR_ERROR, "Function marked GRPC_ABSTRACT was not implemented");
+    GPR_ASSERT(false);
+  }
 
   /// Returns the LB policy name that this factory provides.
   /// Caller does NOT take ownership of result.

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

@@ -84,14 +84,14 @@ void LoadBalancingPolicyRegistry::Builder::RegisterLoadBalancingPolicyFactory(
 
 OrphanablePtr<LoadBalancingPolicy>
 LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-    const char* name, const LoadBalancingPolicy::Args& args) {
+    const char* name, LoadBalancingPolicy::Args args) {
   GPR_ASSERT(g_state != nullptr);
   // Find factory.
   LoadBalancingPolicyFactory* factory =
       g_state->GetLoadBalancingPolicyFactory(name);
   if (factory == nullptr) return nullptr;  // Specified name not found.
   // Create policy via factory.
-  return factory->CreateLoadBalancingPolicy(args);
+  return factory->CreateLoadBalancingPolicy(std::move(args));
 }
 
 bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(const char* name) {

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

@@ -46,7 +46,7 @@ class LoadBalancingPolicyRegistry {
 
   /// Creates an LB policy of the type specified by \a name.
   static OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
-      const char* name, const LoadBalancingPolicy::Args& args);
+      const char* name, LoadBalancingPolicy::Args args);
 
   /// Returns true if the LB policy factory specified by \a name exists in this
   /// registry.

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

@@ -0,0 +1,96 @@
+//
+//
+// Copyright 2018 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.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/local_subchannel_pool.h"
+
+#include "src/core/ext/filters/client_channel/subchannel.h"
+
+namespace grpc_core {
+
+LocalSubchannelPool::LocalSubchannelPool() {
+  subchannel_map_ = grpc_avl_create(&subchannel_avl_vtable_);
+}
+
+LocalSubchannelPool::~LocalSubchannelPool() {
+  grpc_avl_unref(subchannel_map_, nullptr);
+}
+
+Subchannel* LocalSubchannelPool::RegisterSubchannel(SubchannelKey* key,
+                                                    Subchannel* constructed) {
+  // Check to see if a subchannel already exists.
+  Subchannel* c =
+      static_cast<Subchannel*>(grpc_avl_get(subchannel_map_, key, nullptr));
+  if (c != nullptr) {
+    // The subchannel already exists. Reuse it.
+    c = GRPC_SUBCHANNEL_REF(c, "subchannel_register+reuse");
+    GRPC_SUBCHANNEL_UNREF(constructed, "subchannel_register+found_existing");
+  } else {
+    // There hasn't been such subchannel. Add one.
+    subchannel_map_ = grpc_avl_add(subchannel_map_, New<SubchannelKey>(*key),
+                                   constructed, nullptr);
+    c = constructed;
+  }
+  return c;
+}
+
+void LocalSubchannelPool::UnregisterSubchannel(SubchannelKey* key) {
+  subchannel_map_ = grpc_avl_remove(subchannel_map_, key, nullptr);
+}
+
+Subchannel* LocalSubchannelPool::FindSubchannel(SubchannelKey* key) {
+  Subchannel* c =
+      static_cast<Subchannel*>(grpc_avl_get(subchannel_map_, key, nullptr));
+  return c == nullptr ? c : GRPC_SUBCHANNEL_REF(c, "found_from_pool");
+}
+
+namespace {
+
+void sck_avl_destroy(void* p, void* user_data) {
+  SubchannelKey* key = static_cast<SubchannelKey*>(p);
+  Delete(key);
+}
+
+void* sck_avl_copy(void* p, void* unused) {
+  const SubchannelKey* key = static_cast<const SubchannelKey*>(p);
+  auto new_key = New<SubchannelKey>(*key);
+  return static_cast<void*>(new_key);
+}
+
+long sck_avl_compare(void* a, void* b, void* unused) {
+  const SubchannelKey* key_a = static_cast<const SubchannelKey*>(a);
+  const SubchannelKey* key_b = static_cast<const SubchannelKey*>(b);
+  return key_a->Cmp(*key_b);
+}
+
+void scv_avl_destroy(void* p, void* user_data) {}
+
+void* scv_avl_copy(void* p, void* unused) { return p; }
+
+}  // namespace
+
+const grpc_avl_vtable LocalSubchannelPool::subchannel_avl_vtable_ = {
+    sck_avl_destroy,  // destroy_key
+    sck_avl_copy,     // copy_key
+    sck_avl_compare,  // compare_keys
+    scv_avl_destroy,  // destroy_value
+    scv_avl_copy      // copy_value
+};
+
+}  // namespace grpc_core

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

@@ -0,0 +1,56 @@
+/*
+ *
+ * Copyright 2018 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_EXT_FILTERS_CLIENT_CHANNEL_LOCAL_SUBCHANNEL_POOL_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LOCAL_SUBCHANNEL_POOL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
+
+namespace grpc_core {
+
+// The local subchannel pool that is owned by a single channel. It doesn't
+// support subchannel sharing with other channels by nature. Nor does it support
+// subchannel retention when a subchannel is not used. The only real purpose of
+// using this subchannel pool is to allow subchannel reuse within the channel
+// when an incoming resolver update contains some addresses for which the
+// channel has already created subchannels.
+// Thread-unsafe.
+class LocalSubchannelPool final : public SubchannelPoolInterface {
+ public:
+  LocalSubchannelPool();
+  ~LocalSubchannelPool() override;
+
+  // Implements interface methods.
+  // Thread-unsafe. Intended to be invoked within the client_channel combiner.
+  Subchannel* RegisterSubchannel(SubchannelKey* key,
+                                 Subchannel* constructed) override;
+  void UnregisterSubchannel(SubchannelKey* key) override;
+  Subchannel* FindSubchannel(SubchannelKey* key) override;
+
+ private:
+  // The vtable for subchannel operations in an AVL tree.
+  static const grpc_avl_vtable subchannel_avl_vtable_;
+  // A map from subchannel key to subchannel.
+  grpc_avl subchannel_map_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LOCAL_SUBCHANNEL_POOL_H */

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

@@ -19,6 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/parse_address.h"
+#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 
@@ -35,6 +36,11 @@
 #include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
 
+#ifdef GRPC_POSIX_SOCKET
+#include <errno.h>
+#include <net/if.h>
+#endif
+
 #ifdef GRPC_HAVE_UNIX_SOCKET
 
 bool grpc_parse_unix(const grpc_uri* uri,
@@ -69,7 +75,12 @@ bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
   // Split host and port.
   char* host;
   char* port;
-  if (!gpr_split_host_port(hostport, &host, &port)) return false;
+  if (!gpr_split_host_port(hostport, &host, &port)) {
+    if (log_errors) {
+      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
+    }
+    return false;
+  }
   // Parse IP address.
   memset(addr, 0, sizeof(*addr));
   addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
@@ -115,7 +126,12 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
   // Split host and port.
   char* host;
   char* port;
-  if (!gpr_split_host_port(hostport, &host, &port)) return false;
+  if (!gpr_split_host_port(hostport, &host, &port)) {
+    if (log_errors) {
+      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
+    }
+    return false;
+  }
   // Parse IP address.
   memset(addr, 0, sizeof(*addr));
   addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
@@ -150,10 +166,13 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
     if (gpr_parse_bytes_to_uint32(host_end + 1,
                                   strlen(host) - host_without_scope_len - 1,
                                   &sin6_scope_id) == 0) {
-      if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 scope id: '%s'", host_end + 1);
+      if ((sin6_scope_id = grpc_if_nametoindex(host_end + 1)) == 0) {
+        gpr_log(GPR_ERROR,
+                "Invalid interface name: '%s'. "
+                "Non-numeric and failed if_nametoindex.",
+                host_end + 1);
+        goto done;
       }
-      goto done;
     }
     // Handle "sin6_scope_id" being type "u_long". See grpc issue #10027.
     in6->sin6_scope_id = sin6_scope_id;