grpc 1.32.0 → 1.36.0

data/src/core/ext/xds/xds_server_config_fetcher.cc

@@ -0,0 +1,267 @@
+//
+//
+// Copyright 2020 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/xds/xds_certificate_provider.h"
+#include "src/core/ext/xds/xds_client.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/security/credentials/xds/xds_credentials.h"
+#include "src/core/lib/surface/api_trace.h"
+#include "src/core/lib/surface/server.h"
+
+namespace grpc_core {
+
+TraceFlag grpc_xds_server_config_fetcher_trace(false,
+                                               "xds_server_config_fetcher");
+
+namespace {
+
+class XdsServerConfigFetcher : public grpc_server_config_fetcher {
+ public:
+  explicit XdsServerConfigFetcher(RefCountedPtr<XdsClient> xds_client)
+      : xds_client_(std::move(xds_client)) {
+    GPR_ASSERT(xds_client_ != nullptr);
+  }
+
+  void StartWatch(std::string listening_address, grpc_channel_args* args,
+                  std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
+                      watcher) override {
+    grpc_server_config_fetcher::WatcherInterface* watcher_ptr = watcher.get();
+    auto listener_watcher = absl::make_unique<ListenerWatcher>(
+        std::move(watcher), args, xds_client_);
+    auto* listener_watcher_ptr = listener_watcher.get();
+    // TODO(yashykt): Get the resource name id from bootstrap
+    listening_address = absl::StrCat(
+        "grpc/server?xds.resource.listening_address=", listening_address);
+    xds_client_->WatchListenerData(listening_address,
+                                   std::move(listener_watcher));
+    MutexLock lock(&mu_);
+    auto& watcher_state = watchers_[watcher_ptr];
+    watcher_state.listening_address = listening_address;
+    watcher_state.listener_watcher = listener_watcher_ptr;
+  }
+
+  void CancelWatch(
+      grpc_server_config_fetcher::WatcherInterface* watcher) override {
+    MutexLock lock(&mu_);
+    auto it = watchers_.find(watcher);
+    if (it != watchers_.end()) {
+      // Cancel the watch on the listener before erasing
+      xds_client_->CancelListenerDataWatch(it->second.listening_address,
+                                           it->second.listener_watcher,
+                                           false /* delay_unsubscription */);
+      watchers_.erase(it);
+    }
+  }
+
+  // Return the interested parties from the xds client so that it can be polled.
+  grpc_pollset_set* interested_parties() override {
+    return xds_client_->interested_parties();
+  }
+
+ private:
+  class ListenerWatcher : public XdsClient::ListenerWatcherInterface {
+   public:
+    explicit ListenerWatcher(
+        std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
+            server_config_watcher,
+        grpc_channel_args* args, RefCountedPtr<XdsClient> xds_client)
+        : server_config_watcher_(std::move(server_config_watcher)),
+          args_(args),
+          xds_client_(std::move(xds_client)) {}
+
+    ~ListenerWatcher() override { grpc_channel_args_destroy(args_); }
+
+    // Deleted due to special handling required for args_. Copy the channel args
+    // if we ever need these.
+    ListenerWatcher(const ListenerWatcher&) = delete;
+    ListenerWatcher& operator=(const ListenerWatcher&) = delete;
+
+    void OnListenerChanged(XdsApi::LdsUpdate listener) override {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_server_config_fetcher_trace)) {
+        gpr_log(
+            GPR_INFO,
+            "[ListenerWatcher %p] Received LDS update from xds client %p: %s",
+            this, xds_client_.get(), listener.ToString().c_str());
+      }
+      grpc_error* error = GRPC_ERROR_NONE;
+      bool update_needed = UpdateXdsCertificateProvider(listener, &error);
+      if (error != GRPC_ERROR_NONE) {
+        OnError(error);
+        return;
+      }
+      // Only send an update, if something changed.
+      if (updated_once_ && !update_needed) {
+        return;
+      }
+      updated_once_ = true;
+      grpc_channel_args* updated_args = nullptr;
+      if (xds_certificate_provider_ != nullptr) {
+        grpc_arg arg_to_add = xds_certificate_provider_->MakeChannelArg();
+        updated_args = grpc_channel_args_copy_and_add(args_, &arg_to_add, 1);
+      } else {
+        updated_args = grpc_channel_args_copy(args_);
+      }
+      server_config_watcher_->UpdateConfig(updated_args);
+    }
+
+    void OnError(grpc_error* error) override {
+      gpr_log(GPR_ERROR, "ListenerWatcher:%p XdsClient reports error: %s", this,
+              grpc_error_string(error));
+      GRPC_ERROR_UNREF(error);
+      // TODO(yashykt): We might want to bubble this error to the application.
+    }
+
+    void OnResourceDoesNotExist() override {
+      gpr_log(GPR_ERROR,
+              "ListenerWatcher:%p XdsClient reports requested listener does "
+              "not exist",
+              this);
+      // TODO(yashykt): We might want to bubble this error to the application.
+    }
+
+   private:
+    // Returns true if the xds certificate provider changed in a way that
+    // required a new security connector to be created, false otherwise.
+    bool UpdateXdsCertificateProvider(const XdsApi::LdsUpdate& listener,
+                                      grpc_error** error) {
+      // Early out if channel is not configured to use xDS security.
+      grpc_server_credentials* server_creds =
+          grpc_find_server_credentials_in_args(args_);
+      if (server_creds == nullptr ||
+          server_creds->type() != kCredentialsTypeXds) {
+        xds_certificate_provider_ = nullptr;
+        return false;
+      }
+      if (xds_certificate_provider_ == nullptr) {
+        xds_certificate_provider_ = MakeRefCounted<XdsCertificateProvider>();
+      }
+      // Configure root cert.
+      absl::string_view root_provider_instance_name =
+          listener.downstream_tls_context.common_tls_context
+              .combined_validation_context
+              .validation_context_certificate_provider_instance.instance_name;
+      absl::string_view root_provider_cert_name =
+          listener.downstream_tls_context.common_tls_context
+              .combined_validation_context
+              .validation_context_certificate_provider_instance
+              .certificate_name;
+      RefCountedPtr<grpc_tls_certificate_provider> new_root_provider;
+      if (!root_provider_instance_name.empty()) {
+        new_root_provider =
+            xds_client_->certificate_provider_store()
+                .CreateOrGetCertificateProvider(root_provider_instance_name);
+        if (new_root_provider == nullptr) {
+          *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+              absl::StrCat("Certificate provider instance name: \"",
+                           root_provider_instance_name, "\" not recognized.")
+                  .c_str());
+          return false;
+        }
+      }
+      // Configure identity cert.
+      absl::string_view identity_provider_instance_name =
+          listener.downstream_tls_context.common_tls_context
+              .tls_certificate_certificate_provider_instance.instance_name;
+      absl::string_view identity_provider_cert_name =
+          listener.downstream_tls_context.common_tls_context
+              .tls_certificate_certificate_provider_instance.certificate_name;
+      RefCountedPtr<grpc_tls_certificate_provider> new_identity_provider;
+      if (!identity_provider_instance_name.empty()) {
+        new_identity_provider = xds_client_->certificate_provider_store()
+                                    .CreateOrGetCertificateProvider(
+                                        identity_provider_instance_name);
+        if (new_identity_provider == nullptr) {
+          *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+              absl::StrCat("Certificate provider instance name: \"",
+                           identity_provider_instance_name,
+                           "\" not recognized.")
+                  .c_str());
+          return false;
+        }
+      }
+      bool security_connector_update_required = false;
+      if (((new_root_provider == nullptr) !=
+           (root_certificate_provider_ == nullptr)) ||
+          ((new_identity_provider == nullptr) !=
+           (identity_certificate_provider_ == nullptr)) ||
+          (listener.downstream_tls_context.require_client_certificate !=
+           xds_certificate_provider_->GetRequireClientCertificate(""))) {
+        security_connector_update_required = true;
+      }
+      if (root_certificate_provider_ != new_root_provider) {
+        root_certificate_provider_ = std::move(new_root_provider);
+      }
+      if (identity_certificate_provider_ != new_identity_provider) {
+        identity_certificate_provider_ = std::move(new_identity_provider);
+      }
+      xds_certificate_provider_->UpdateRootCertNameAndDistributor(
+          "", root_provider_cert_name,
+          root_certificate_provider_ == nullptr
+              ? nullptr
+              : root_certificate_provider_->distributor());
+      xds_certificate_provider_->UpdateIdentityCertNameAndDistributor(
+          "", identity_provider_cert_name,
+          identity_certificate_provider_ == nullptr
+              ? nullptr
+              : identity_certificate_provider_->distributor());
+      xds_certificate_provider_->UpdateRequireClientCertificate(
+          "", listener.downstream_tls_context.require_client_certificate);
+      return security_connector_update_required;
+    }
+
+    std::unique_ptr<grpc_server_config_fetcher::WatcherInterface>
+        server_config_watcher_;
+    grpc_channel_args* args_;
+    RefCountedPtr<XdsClient> xds_client_;
+    RefCountedPtr<grpc_tls_certificate_provider> root_certificate_provider_;
+    RefCountedPtr<grpc_tls_certificate_provider> identity_certificate_provider_;
+    RefCountedPtr<XdsCertificateProvider> xds_certificate_provider_;
+    bool updated_once_ = false;
+  };
+
+  struct WatcherState {
+    std::string listening_address;
+    ListenerWatcher* listener_watcher = nullptr;
+  };
+
+  RefCountedPtr<XdsClient> xds_client_;
+  Mutex mu_;
+  std::map<grpc_server_config_fetcher::WatcherInterface*, WatcherState>
+      watchers_;
+};
+
+}  // namespace
+}  // namespace grpc_core
+
+grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create() {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_config_fetcher_xds_create()", 0, ());
+  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_core::RefCountedPtr<grpc_core::XdsClient> xds_client =
+      grpc_core::XdsClient::GetOrCreate(&error);
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "Failed to create xds client: %s",
+            grpc_error_string(error));
+    GRPC_ERROR_UNREF(error);
+    return nullptr;
+  }
+  return new grpc_core::XdsServerConfigFetcher(std::move(xds_client));
+}

data/src/core/lib/channel/channel_args.cc

@@ -178,20 +178,21 @@ static int cmp_key_stable(const void* ap, const void* bp) {
   return c;
 }
 
-grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
+grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* src) {
   grpc_arg** args =
-      static_cast<grpc_arg**>(gpr_malloc(sizeof(grpc_arg*) * a->num_args));
-  for (size_t i = 0; i < a->num_args; i++) {
-    args[i] = &a->args[i];
+      static_cast<grpc_arg**>(gpr_malloc(sizeof(grpc_arg*) * src->num_args));
+  for (size_t i = 0; i < src->num_args; i++) {
+    args[i] = &src->args[i];
+  }
+  if (src->num_args > 1) {
+    qsort(args, src->num_args, sizeof(grpc_arg*), cmp_key_stable);
   }
-  if (a->num_args > 1)
-    qsort(args, a->num_args, sizeof(grpc_arg*), cmp_key_stable);
 
   grpc_channel_args* b =
       static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
-  b->num_args = a->num_args;
+  b->num_args = src->num_args;
   b->args = static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * b->num_args));
-  for (size_t i = 0; i < a->num_args; i++) {
+  for (size_t i = 0; i < src->num_args; i++) {
     b->args[i] = copy_arg(args[i]);
   }
 

data/src/core/lib/channel/channel_args.h

@@ -117,7 +117,6 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
                                          const grpc_arg_pointer_vtable* vtable);
 
 // Returns a string representing channel args in human-readable form.
-// Callers takes ownership of result.
 std::string grpc_channel_args_string(const grpc_channel_args* args);
 
 // Takes ownership of the old_args

data/src/core/lib/channel/channel_trace.cc

@@ -67,16 +67,18 @@ ChannelTrace::ChannelTrace(size_t max_event_memory)
       max_event_memory_(max_event_memory),
       head_trace_(nullptr),
       tail_trace_(nullptr) {
-  if (max_event_memory_ == 0)
+  if (max_event_memory_ == 0) {
     return;  // tracing is disabled if max_event_memory_ == 0
+  }
   gpr_mu_init(&tracer_mu_);
   time_created_ = grpc_millis_to_timespec(grpc_core::ExecCtx::Get()->Now(),
                                           GPR_CLOCK_REALTIME);
 }
 
 ChannelTrace::~ChannelTrace() {
-  if (max_event_memory_ == 0)
+  if (max_event_memory_ == 0) {
     return;  // tracing is disabled if max_event_memory_ == 0
+  }
   TraceEvent* it = head_trace_;
   while (it != nullptr) {
     TraceEvent* to_free = it;

data/src/core/lib/channel/channel_trace.h

@@ -41,7 +41,7 @@ class BaseNode;
 // https://github.com/grpc/proposal/blob/master/A14-channelz.md
 class ChannelTrace {
  public:
-  ChannelTrace(size_t max_event_memory);
+  explicit ChannelTrace(size_t max_event_memory);
   ~ChannelTrace();
 
   enum Severity {

data/src/core/lib/channel/channelz.cc

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/channel/channelz.h"
 
+#include "absl/strings/strip.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -48,40 +50,6 @@
 namespace grpc_core {
 namespace channelz {
 
-//
-// channel arg code
-//
-
-namespace {
-
-void* parent_uuid_copy(void* p) { return p; }
-void parent_uuid_destroy(void* /*p*/) {}
-int parent_uuid_cmp(void* p1, void* p2) { return GPR_ICMP(p1, p2); }
-const grpc_arg_pointer_vtable parent_uuid_vtable = {
-    parent_uuid_copy, parent_uuid_destroy, parent_uuid_cmp};
-
-}  // namespace
-
-grpc_arg MakeParentUuidArg(intptr_t parent_uuid) {
-  // We would ideally like to store the uuid in an integer argument.
-  // Unfortunately, that won't work, because intptr_t (the type used for
-  // uuids) doesn't fit in an int (the type used for integer args).
-  // So instead, we use a hack to store it as a pointer, because
-  // intptr_t should be the same size as void*.
-  static_assert(sizeof(intptr_t) <= sizeof(void*),
-                "can't fit intptr_t inside of void*");
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_CHANNELZ_PARENT_UUID),
-      reinterpret_cast<void*>(parent_uuid), &parent_uuid_vtable);
-}
-
-intptr_t GetParentUuidFromArgs(const grpc_channel_args& args) {
-  const grpc_arg* arg =
-      grpc_channel_args_find(&args, GRPC_ARG_CHANNELZ_PARENT_UUID);
-  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return 0;
-  return reinterpret_cast<intptr_t>(arg->value.pointer.p);
-}
-
 //
 // BaseNode
 //
@@ -148,21 +116,21 @@ void CallCountingHelper::CollectData(CounterData* out) {
   }
 }
 
-void CallCountingHelper::PopulateCallCounts(Json::Object* object) {
+void CallCountingHelper::PopulateCallCounts(Json::Object* json) {
   CounterData data;
   CollectData(&data);
   if (data.calls_started != 0) {
-    (*object)["callsStarted"] = std::to_string(data.calls_started);
+    (*json)["callsStarted"] = std::to_string(data.calls_started);
     gpr_timespec ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(data.last_call_started_cycle),
         GPR_CLOCK_REALTIME);
-    (*object)["lastCallStartedTimestamp"] = gpr_format_timespec(ts);
+    (*json)["lastCallStartedTimestamp"] = gpr_format_timespec(ts);
   }
   if (data.calls_succeeded != 0) {
-    (*object)["callsSucceeded"] = std::to_string(data.calls_succeeded);
+    (*json)["callsSucceeded"] = std::to_string(data.calls_succeeded);
   }
   if (data.calls_failed) {
-    (*object)["callsFailed"] = std::to_string(data.calls_failed);
+    (*json)["callsFailed"] = std::to_string(data.calls_failed);
   }
 }
 
@@ -171,13 +139,12 @@ void CallCountingHelper::PopulateCallCounts(Json::Object* object) {
 //
 
 ChannelNode::ChannelNode(std::string target, size_t channel_tracer_max_nodes,
-                         intptr_t parent_uuid)
-    : BaseNode(parent_uuid == 0 ? EntityType::kTopLevelChannel
-                                : EntityType::kInternalChannel,
+                         bool is_internal_channel)
+    : BaseNode(is_internal_channel ? EntityType::kInternalChannel
+                                   : EntityType::kTopLevelChannel,
                target),
       target_(std::move(target)),
-      trace_(channel_tracer_max_nodes),
-      parent_uuid_(parent_uuid) {}
+      trace_(channel_tracer_max_nodes) {}
 
 const char* ChannelNode::GetChannelConnectivityStateChangeString(
     grpc_connectivity_state state) {
@@ -235,18 +202,18 @@ void ChannelNode::PopulateChildRefs(Json::Object* json) {
   MutexLock lock(&child_mu_);
   if (!child_subchannels_.empty()) {
     Json::Array array;
-    for (const auto& p : child_subchannels_) {
+    for (intptr_t subchannel_uuid : child_subchannels_) {
       array.emplace_back(Json::Object{
-          {"subchannelId", std::to_string(p.first)},
+          {"subchannelId", std::to_string(subchannel_uuid)},
       });
     }
     (*json)["subchannelRef"] = std::move(array);
   }
   if (!child_channels_.empty()) {
     Json::Array array;
-    for (const auto& p : child_channels_) {
+    for (intptr_t channel_uuid : child_channels_) {
       array.emplace_back(Json::Object{
-          {"channelId", std::to_string(p.first)},
+          {"channelId", std::to_string(channel_uuid)},
       });
     }
     (*json)["channelRef"] = std::move(array);
@@ -261,7 +228,7 @@ void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
 
 void ChannelNode::AddChildChannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_channels_.insert(std::make_pair(child_uuid, true));
+  child_channels_.insert(child_uuid);
 }
 
 void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
@@ -271,7 +238,7 @@ void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
 
 void ChannelNode::AddChildSubchannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_subchannels_.insert(std::make_pair(child_uuid, true));
+  child_subchannels_.insert(child_uuid);
 }
 
 void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
@@ -379,14 +346,12 @@ void PopulateSocketAddressJson(Json::Object* json, const char* name,
                                const char* addr_str) {
   if (addr_str == nullptr) return;
   Json::Object data;
-  grpc_uri* uri = grpc_uri_parse(addr_str, true);
-  if ((uri != nullptr) && ((strcmp(uri->scheme, "ipv4") == 0) ||
-                           (strcmp(uri->scheme, "ipv6") == 0))) {
-    const char* host_port = uri->path;
-    if (*host_port == '/') ++host_port;
+  absl::StatusOr<URI> uri = URI::Parse(addr_str);
+  if (uri.ok() && (uri->scheme() == "ipv4" || uri->scheme() == "ipv6")) {
     std::string host;
     std::string port;
-    GPR_ASSERT(SplitHostPort(host_port, &host, &port));
+    GPR_ASSERT(
+        SplitHostPort(absl::StripPrefix(uri->path(), "/"), &host, &port));
     int port_num = -1;
     if (!port.empty()) {
       port_num = atoi(port.data());
@@ -397,16 +362,15 @@ void PopulateSocketAddressJson(Json::Object* json, const char* name,
         {"ip_address", b64_host},
     };
     gpr_free(b64_host);
-  } else if (uri != nullptr && strcmp(uri->scheme, "unix") == 0) {
+  } else if (uri.ok() && uri->scheme() == "unix") {
     data["uds_address"] = Json::Object{
-        {"filename", uri->path},
+        {"filename", uri->path()},
     };
   } else {
     data["other_address"] = Json::Object{
         {"name", addr_str},
     };
   }
-  grpc_uri_destroy(uri);
   (*json)[name] = std::move(data);
 }