grpc 1.32.0 → 1.36.0

data/src/core/lib/surface/lame_client.cc

@@ -39,59 +39,25 @@ namespace grpc_core {
 
 namespace {
 
-struct CallData {
-  CallCombiner* call_combiner;
-  grpc_linked_mdelem status;
-  grpc_linked_mdelem details;
-  Atomic<bool> filled_metadata;
-};
-
 struct ChannelData {
   ChannelData() : state_tracker("lame_channel", GRPC_CHANNEL_SHUTDOWN) {}
+  ~ChannelData() { GRPC_ERROR_UNREF(error); }
 
-  grpc_status_code error_code;
-  const char* error_message;
+  grpc_error* error = GRPC_ERROR_NONE;
   Mutex mu;
   ConnectivityStateTracker state_tracker;
 };
 
-static void fill_metadata(grpc_call_element* elem, grpc_metadata_batch* mdb) {
-  CallData* calld = static_cast<CallData*>(elem->call_data);
-  bool expected = false;
-  if (!calld->filled_metadata.CompareExchangeStrong(
-          &expected, true, MemoryOrder::RELAXED, MemoryOrder::RELAXED)) {
-    return;
-  }
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  char tmp[GPR_LTOA_MIN_BUFSIZE];
-  gpr_ltoa(chand->error_code, tmp);
-  calld->status.md = grpc_mdelem_from_slices(
-      GRPC_MDSTR_GRPC_STATUS, grpc_core::UnmanagedMemorySlice(tmp));
-  calld->details.md = grpc_mdelem_from_slices(
-      GRPC_MDSTR_GRPC_MESSAGE,
-      grpc_core::UnmanagedMemorySlice(chand->error_message));
-  calld->status.prev = calld->details.next = nullptr;
-  calld->status.next = &calld->details;
-  calld->details.prev = &calld->status;
-  mdb->list.head = &calld->status;
-  mdb->list.tail = &calld->details;
-  mdb->list.count = 2;
-  mdb->deadline = GRPC_MILLIS_INF_FUTURE;
-}
+struct CallData {
+  CallCombiner* call_combiner;
+};
 
 static void lame_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (op->recv_initial_metadata) {
-    fill_metadata(elem,
-                  op->payload->recv_initial_metadata.recv_initial_metadata);
-  } else if (op->recv_trailing_metadata) {
-    fill_metadata(elem,
-                  op->payload->recv_trailing_metadata.recv_trailing_metadata);
-  }
+  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   grpc_transport_stream_op_batch_finish_with_failure(
-      op, GRPC_ERROR_CREATE_FROM_STATIC_STRING("lame client channel"),
-      calld->call_combiner);
+      op, GRPC_ERROR_REF(chand->error), calld->call_combiner);
 }
 
 static void lame_get_channel_info(grpc_channel_element* /*elem*/,
@@ -152,6 +118,12 @@ static void lame_destroy_channel_elem(grpc_channel_element* elem) {
 
 }  // namespace
 
+void SetLameFilterError(grpc_channel_element* elem, grpc_error* error) {
+  GPR_ASSERT(elem->filter == &grpc_lame_filter);
+  auto chand = static_cast<grpc_core::ChannelData*>(elem->channel_data);
+  chand->error = error;
+}
+
 }  // namespace grpc_core
 
 const grpc_channel_filter grpc_lame_filter = {
@@ -182,10 +154,12 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
       "grpc_lame_client_channel_create(target=%s, error_code=%d, "
       "error_message=%s)",
       3, (target, (int)error_code, error_message));
-  GPR_ASSERT(elem->filter == &grpc_lame_filter);
-  auto chand = static_cast<grpc_core::ChannelData*>(elem->channel_data);
-  chand->error_code = error_code;
-  chand->error_message = error_message;
-
+  grpc_core::SetLameFilterError(
+      elem, grpc_error_set_str(
+                grpc_error_set_int(
+                    GRPC_ERROR_CREATE_FROM_STATIC_STRING("lame client channel"),
+                    GRPC_ERROR_INT_GRPC_STATUS, error_code),
+                GRPC_ERROR_STR_GRPC_MESSAGE,
+                grpc_slice_from_static_string(error_message)));
   return channel;
 }

data/src/core/lib/surface/lame_client.h

@@ -25,4 +25,8 @@
 
 extern const grpc_channel_filter grpc_lame_filter;
 
+namespace grpc_core {
+void SetLameFilterError(grpc_channel_element* elem, grpc_error* error);
+}  // namespace grpc_core
+
 #endif /* GRPC_CORE_LIB_SURFACE_LAME_CLIENT_H */

data/src/core/lib/surface/server.cc

@@ -30,6 +30,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/memory/memory.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/alloc.h>
@@ -512,7 +513,7 @@ grpc_resource_user* CreateDefaultResourceUser(const grpc_channel_args* args) {
 }
 
 RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
-    Server* server, const grpc_channel_args* args) {
+    const grpc_channel_args* args) {
   RefCountedPtr<channelz::ServerNode> channelz_node;
   if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ,
                                   GRPC_ENABLE_CHANNELZ_DEFAULT)) {
@@ -533,10 +534,18 @@ RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
 Server::Server(const grpc_channel_args* args)
     : channel_args_(grpc_channel_args_copy(args)),
       default_resource_user_(CreateDefaultResourceUser(args)),
-      channelz_node_(CreateChannelzNode(this, args)) {}
+      channelz_node_(CreateChannelzNode(args)) {}
 
 Server::~Server() {
   grpc_channel_args_destroy(channel_args_);
+  // Remove the cq pollsets from the config_fetcher.
+  if (started_ && config_fetcher_ != nullptr &&
+      config_fetcher_->interested_parties() != nullptr) {
+    for (grpc_pollset* pollset : pollsets_) {
+      grpc_pollset_set_del_pollset(config_fetcher_->interested_parties(),
+                                   pollset);
+    }
+  }
   for (size_t i = 0; i < cqs_.size(); i++) {
     GRPC_CQ_INTERNAL_UNREF(cqs_[i], "server");
   }
@@ -570,6 +579,16 @@ void Server::Start() {
     MutexLock lock(&mu_global_);
     starting_ = true;
   }
+  // Register the interested parties from the config fetcher to the cq pollsets
+  // before starting listeners so that config fetcher is being polled when the
+  // listeners start watch the fetcher.
+  if (config_fetcher_ != nullptr &&
+      config_fetcher_->interested_parties() != nullptr) {
+    for (grpc_pollset* pollset : pollsets_) {
+      grpc_pollset_set_add_pollset(config_fetcher_->interested_parties(),
+                                   pollset);
+    }
+  }
   for (auto& listener : listeners_) {
     listener.listener->Start(this, &pollsets_);
   }
@@ -578,14 +597,18 @@ void Server::Start() {
   starting_cv_.Signal();
 }
 
-void Server::SetupTransport(
+grpc_error* Server::SetupTransport(
     grpc_transport* transport, grpc_pollset* accepting_pollset,
     const grpc_channel_args* args,
     const RefCountedPtr<grpc_core::channelz::SocketNode>& socket_node,
     grpc_resource_user* resource_user) {
   // Create channel.
+  grpc_error* error = GRPC_ERROR_NONE;
   grpc_channel* channel = grpc_channel_create(
-      nullptr, args, GRPC_SERVER_CHANNEL, transport, resource_user);
+      nullptr, args, GRPC_SERVER_CHANNEL, transport, resource_user, &error);
+  if (channel == nullptr) {
+    return error;
+  }
   ChannelData* chand = static_cast<ChannelData*>(
       grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
           ->channel_data);
@@ -606,6 +629,7 @@ void Server::SetupTransport(
   }
   // Initialize chand.
   chand->InitTransport(Ref(), channel, cq_idx, transport, channelz_socket_uuid);
+  return GRPC_ERROR_NONE;
 }
 
 bool Server::HasOpenConnections() {
@@ -772,7 +796,7 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
   {
     // Wait for startup to be finished.  Locks mu_global.
     MutexLock lock(&mu_global_);
-    starting_cv_.WaitUntil(&mu_global_, [this] { return !starting_; });
+    WaitUntil(&starting_cv_, &mu_global_, [this] { return !starting_; });
     // Stay locked, and gather up some stuff to do.
     GPR_ASSERT(grpc_cq_begin_op(cq, tag));
     if (shutdown_published_) {
@@ -936,7 +960,7 @@ class Server::ChannelData::ConnectivityWatcher
     GRPC_CHANNEL_INTERNAL_REF(chand_->channel_, "connectivity");
   }
 
-  ~ConnectivityWatcher() {
+  ~ConnectivityWatcher() override {
     GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel_, "connectivity");
   }
 
@@ -1000,7 +1024,8 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
   if (num_registered_methods > 0) {
     uint32_t max_probes = 0;
     size_t slots = 2 * num_registered_methods;
-    registered_methods_.reset(new std::vector<ChannelRegisteredMethod>(slots));
+    registered_methods_ =
+        absl::make_unique<std::vector<ChannelRegisteredMethod>>(slots);
     for (std::unique_ptr<RegisteredMethod>& rm : server_->registered_methods_) {
       ExternallyManagedSlice host;
       ExternallyManagedSlice method(rm->method.c_str());
@@ -1113,8 +1138,8 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   calld->Start(elem);
 }
 
-void Server::ChannelData::FinishDestroy(void* cd, grpc_error* /*error*/) {
-  auto* chand = static_cast<Server::ChannelData*>(cd);
+void Server::ChannelData::FinishDestroy(void* arg, grpc_error* /*error*/) {
+  auto* chand = static_cast<Server::ChannelData*>(arg);
   Server* server = chand->server_.get();
   GRPC_CHANNEL_INTERNAL_UNREF(chand->channel_, "server");
   server->Unref();
@@ -1353,8 +1378,8 @@ void Server::CallData::StartTransportStreamOpBatchImpl(
   grpc_call_next_op(elem, batch);
 }
 
-void Server::CallData::RecvInitialMetadataReady(void* ptr, grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
+void Server::CallData::RecvInitialMetadataReady(void* arg, grpc_error* error) {
+  grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   grpc_millis op_deadline;
   if (error == GRPC_ERROR_NONE) {
@@ -1396,9 +1421,8 @@ void Server::CallData::RecvInitialMetadataReady(void* ptr, grpc_error* error) {
   Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
-void Server::CallData::RecvTrailingMetadataReady(void* user_data,
-                                                 grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
+void Server::CallData::RecvTrailingMetadataReady(void* arg, grpc_error* error) {
+  grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   if (calld->original_recv_initial_metadata_ready_ != nullptr) {
     calld->recv_trailing_metadata_error_ = GRPC_ERROR_REF(error);
@@ -1533,23 +1557,45 @@ grpc_call_error grpc_server_request_call(
 }
 
 grpc_call_error grpc_server_request_registered_call(
-    grpc_server* server, void* rmp, grpc_call** call, gpr_timespec* deadline,
-    grpc_metadata_array* request_metadata, grpc_byte_buffer** optional_payload,
+    grpc_server* server, void* registered_method, grpc_call** call,
+    gpr_timespec* deadline, grpc_metadata_array* request_metadata,
+    grpc_byte_buffer** optional_payload,
     grpc_completion_queue* cq_bound_to_call,
     grpc_completion_queue* cq_for_notification, void* tag_new) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
-  auto* rm = static_cast<grpc_core::Server::RegisteredMethod*>(rmp);
+  auto* rm =
+      static_cast<grpc_core::Server::RegisteredMethod*>(registered_method);
   GRPC_API_TRACE(
       "grpc_server_request_registered_call("
-      "server=%p, rmp=%p, call=%p, deadline=%p, request_metadata=%p, "
+      "server=%p, registered_method=%p, call=%p, deadline=%p, "
+      "request_metadata=%p, "
       "optional_payload=%p, cq_bound_to_call=%p, cq_for_notification=%p, "
       "tag=%p)",
       9,
-      (server, rmp, call, deadline, request_metadata, optional_payload,
-       cq_bound_to_call, cq_for_notification, tag_new));
+      (server, registered_method, call, deadline, request_metadata,
+       optional_payload, cq_bound_to_call, cq_for_notification, tag_new));
   return server->core_server->RequestRegisteredCall(
       rm, call, deadline, request_metadata, optional_payload, cq_bound_to_call,
       cq_for_notification, tag_new);
 }
+
+void grpc_server_set_config_fetcher(
+    grpc_server* server, grpc_server_config_fetcher* server_config_fetcher) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_set_config_fetcher(server=%p, config_fetcher=%p)",
+                 2, (server, server_config_fetcher));
+  server->core_server->set_config_fetcher(
+      std::unique_ptr<grpc_server_config_fetcher>(server_config_fetcher));
+}
+
+void grpc_server_config_fetcher_destroy(
+    grpc_server_config_fetcher* server_config_fetcher) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE("grpc_server_config_fetcher_destroy(config_fetcher=%p)", 1,
+                 (server_config_fetcher));
+  delete server_config_fetcher;
+}

data/src/core/lib/surface/server.h

@@ -71,7 +71,7 @@ class Server : public InternallyRefCounted<Server> {
   /// listening and initiate destruction of the listener.
   class ListenerInterface : public Orphanable {
    public:
-    virtual ~ListenerInterface() = default;
+    ~ListenerInterface() override = default;
 
     /// Starts listening. This listener may refer to the pollset object beyond
     /// this call, so it is a pointer rather than a reference.
@@ -88,7 +88,7 @@ class Server : public InternallyRefCounted<Server> {
   };
 
   explicit Server(const grpc_channel_args* args);
-  ~Server();
+  ~Server() override;
 
   void Orphan() override;
 
@@ -103,6 +103,15 @@ class Server : public InternallyRefCounted<Server> {
   // result is valid for the lifetime of the server.
   const std::vector<grpc_pollset*>& pollsets() const { return pollsets_; }
 
+  grpc_server_config_fetcher* config_fetcher() const {
+    return config_fetcher_.get();
+  }
+
+  void set_config_fetcher(
+      std::unique_ptr<grpc_server_config_fetcher> config_fetcher) {
+    config_fetcher_ = std::move(config_fetcher);
+  }
+
   bool HasOpenConnections();
 
   // Adds a listener to the server.  When the server starts, it will call
@@ -115,11 +124,11 @@ class Server : public InternallyRefCounted<Server> {
 
   // Sets up a transport.  Creates a channel stack and binds the transport to
   // the server.  Called from the listener when a new connection is accepted.
-  void SetupTransport(grpc_transport* transport,
-                      grpc_pollset* accepting_pollset,
-                      const grpc_channel_args* args,
-                      const RefCountedPtr<channelz::SocketNode>& socket_node,
-                      grpc_resource_user* resource_user = nullptr);
+  grpc_error* SetupTransport(
+      grpc_transport* transport, grpc_pollset* accepting_pollset,
+      const grpc_channel_args* args,
+      const RefCountedPtr<channelz::SocketNode>& socket_node,
+      grpc_resource_user* resource_user = nullptr);
 
   void RegisterCompletionQueue(grpc_completion_queue* cq);
 
@@ -350,6 +359,7 @@ class Server : public InternallyRefCounted<Server> {
   grpc_channel_args* const channel_args_;
   grpc_resource_user* default_resource_user_ = nullptr;
   RefCountedPtr<channelz::ServerNode> channelz_node_;
+  std::unique_ptr<grpc_server_config_fetcher> config_fetcher_;
 
   std::vector<grpc_completion_queue*> cqs_;
   std::vector<grpc_pollset*> pollsets_;
@@ -394,4 +404,29 @@ struct grpc_server {
   grpc_core::OrphanablePtr<grpc_core::Server> core_server;
 };
 
+// TODO(roth): Eventually, will need a way to modify configuration even after
+// a connection is established (e.g., to change things like L7 rate
+// limiting, RBAC, and fault injection configs).  One possible option
+// would be to do something like ServiceConfig and ConfigSelector, but
+// that might add unnecessary per-call overhead.  Need to consider other
+// approaches here.
+struct grpc_server_config_fetcher {
+ public:
+  class WatcherInterface {
+   public:
+    virtual ~WatcherInterface() = default;
+    // Ownership of \a args is transferred.
+    virtual void UpdateConfig(grpc_channel_args* args) = 0;
+  };
+
+  virtual ~grpc_server_config_fetcher() = default;
+
+  // Ownership of \a args is transferred.
+  virtual void StartWatch(std::string listening_address,
+                          grpc_channel_args* args,
+                          std::unique_ptr<WatcherInterface> watcher) = 0;
+  virtual void CancelWatch(WatcherInterface* watcher) = 0;
+  virtual grpc_pollset_set* interested_parties() = 0;
+};
+
 #endif /* GRPC_CORE_LIB_SURFACE_SERVER_H */

data/src/core/lib/surface/validate_metadata.h

@@ -21,7 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstring>
+
 #include <grpc/slice.h>
+
 #include "src/core/lib/iomgr/error.h"
 
 grpc_error* grpc_validate_header_key_is_legal(const grpc_slice& slice);

data/src/core/lib/surface/version.cc

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "12.0.0"; }
+const char* grpc_version_string(void) { return "15.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "giggle"; }
+const char* grpc_g_stands_for(void) { return "gummybear"; }

data/src/core/lib/transport/authority_override.cc

@@ -16,6 +16,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
 #include "src/core/lib/channel/channel_args.h"
 
 // Channel arg key for the authority override.
@@ -23,16 +25,16 @@
 
 namespace grpc_core {
 
-/// Returns a channel argument containing \a authority.
 grpc_arg CreateAuthorityOverrideChannelArg(const char* authority) {
   return grpc_channel_arg_string_create(
       const_cast<char*>(GRPC_ARG_AUTHORITY_OVERRIDE),
       const_cast<char*>(authority));
 }
 
-/// Returns the authority override from \a args or nullptr.
-const char* FindAuthorityOverrideInArgs(const grpc_channel_args* args) {
-  return grpc_channel_args_find_string(args, GRPC_ARG_AUTHORITY_OVERRIDE);
+absl::string_view FindAuthorityOverrideInArgs(const grpc_channel_args* args) {
+  const char* found =
+      grpc_channel_args_find_string(args, GRPC_ARG_AUTHORITY_OVERRIDE);
+  return found == nullptr ? "" : found;
 }
 
 }  // namespace grpc_core

data/src/core/lib/transport/authority_override.h

@@ -19,13 +19,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
+#include <grpc/grpc.h>
+
 namespace grpc_core {
 
 /// Returns a channel argument containing \a authority.
 grpc_arg CreateAuthorityOverrideChannelArg(const char* authority);
 
-/// Returns the authority override from \a args or nullptr.
-const char* FindAuthorityOverrideInArgs(const grpc_channel_args* args);
+/// Returns the authority override from \a args or the empty string. The return
+/// value is a string_view into the `args` data structure.
+absl::string_view FindAuthorityOverrideInArgs(const grpc_channel_args* args);
 
 }  // namespace grpc_core