grpc 1.31.1 → 1.32.0.pre1

data/src/core/ext/filters/max_age/max_age_filter.cc

@@ -229,7 +229,8 @@ class ConnectivityWatcher : public AsyncConnectivityStateWatcherInterface {
   }
 
  private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+  void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                 const absl::Status& /* status */) override {
     if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
     {
       MutexLock lock(&chand_->max_age_timer_mu);

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -129,6 +129,15 @@ void Chttp2Connector::StartHandshakeLocked() {
   endpoint_ = nullptr;  // Endpoint handed off to handshake manager.
 }
 
+namespace {
+void NullThenSchedClosure(const DebugLocation& location, grpc_closure** closure,
+                          grpc_error* error) {
+  grpc_closure* c = *closure;
+  *closure = nullptr;
+  ExecCtx::Run(location, c, error);
+}
+}  // namespace
+
 void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error* error) {
   auto* args = static_cast<HandshakerArgs*>(arg);
   Chttp2Connector* self = static_cast<Chttp2Connector*>(args->user_data);
@@ -154,53 +163,100 @@ void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error* error) {
         error = GRPC_ERROR_REF(error);
       }
       self->result_->Reset();
+      NullThenSchedClosure(DEBUG_LOCATION, &self->notify_, error);
     } else if (args->endpoint != nullptr) {
-      grpc_endpoint_delete_from_pollset_set(args->endpoint,
-                                            self->args_.interested_parties);
       self->result_->transport =
           grpc_create_chttp2_transport(args->args, args->endpoint, true);
       self->result_->socket_node =
           grpc_chttp2_transport_get_socket_node(self->result_->transport);
+      self->result_->channel_args = args->args;
       GPR_ASSERT(self->result_->transport != nullptr);
-      // TODO(roth): We ideally want to wait until we receive HTTP/2
-      // settings from the server before we consider the connection
-      // established.  If that doesn't happen before the connection
-      // timeout expires, then we should consider the connection attempt a
-      // failure and feed that information back into the backoff code.
-      // We could pass a notify_on_receive_settings callback to
-      // grpc_chttp2_transport_start_reading() to let us know when
-      // settings are received, but we would need to figure out how to use
-      // that information here.
-      //
-      // Unfortunately, we don't currently have a way to split apart the two
-      // effects of scheduling c->notify: we start sending RPCs immediately
-      // (which we want to do) and we consider the connection attempt successful
-      // (which we don't want to do until we get the notify_on_receive_settings
-      // callback from the transport).  If we could split those things
-      // apart, then we could start sending RPCs but then wait for our
-      // timeout before deciding if the connection attempt is successful.
-      // If the attempt is not successful, then we would tear down the
-      // transport and feed the failure back into the backoff code.
-      //
-      // In addition, even if we did that, we would probably not want to do
-      // so until after transparent retries is implemented.  Otherwise, any
-      // RPC that we attempt to send on the connection before the timeout
-      // would fail instead of being retried on a subsequent attempt.
+      self->endpoint_ = args->endpoint;
+      self->Ref().release();  // Ref held by OnReceiveSettings()
+      GRPC_CLOSURE_INIT(&self->on_receive_settings_, OnReceiveSettings, self,
+                        grpc_schedule_on_exec_ctx);
+      self->Ref().release();  // Ref held by OnTimeout()
       grpc_chttp2_transport_start_reading(self->result_->transport,
-                                          args->read_buffer, nullptr);
-      self->result_->channel_args = args->args;
+                                          args->read_buffer,
+                                          &self->on_receive_settings_);
+      GRPC_CLOSURE_INIT(&self->on_timeout_, OnTimeout, self,
+                        grpc_schedule_on_exec_ctx);
+      grpc_timer_init(&self->timer_, self->args_.deadline, &self->on_timeout_);
     } else {
       // If the handshaking succeeded but there is no endpoint, then the
       // handshaker may have handed off the connection to some external
       // code. Just verify that exit_early flag is set.
       GPR_DEBUG_ASSERT(args->exit_early);
+      NullThenSchedClosure(DEBUG_LOCATION, &self->notify_, error);
     }
-    grpc_closure* notify = self->notify_;
-    self->notify_ = nullptr;
-    ExecCtx::Run(DEBUG_LOCATION, notify, error);
     self->handshake_mgr_.reset();
   }
   self->Unref();
 }
 
+void Chttp2Connector::OnReceiveSettings(void* arg, grpc_error* error) {
+  Chttp2Connector* self = static_cast<Chttp2Connector*>(arg);
+  {
+    MutexLock lock(&self->mu_);
+    if (!self->notify_error_.has_value()) {
+      grpc_endpoint_delete_from_pollset_set(self->endpoint_,
+                                            self->args_.interested_parties);
+      if (error != GRPC_ERROR_NONE) {
+        // Transport got an error while waiting on SETTINGS frame.
+        // TODO(yashykt): The following two lines should be moved to
+        // SubchannelConnector::Result::Reset()
+        grpc_transport_destroy(self->result_->transport);
+        grpc_channel_args_destroy(self->result_->channel_args);
+        self->result_->Reset();
+      }
+      self->MaybeNotify(GRPC_ERROR_REF(error));
+      grpc_timer_cancel(&self->timer_);
+    } else {
+      // OnTimeout() was already invoked. Call Notify() again so that notify_
+      // can be invoked.
+      self->MaybeNotify(GRPC_ERROR_NONE);
+    }
+  }
+  self->Unref();
+}
+
+void Chttp2Connector::OnTimeout(void* arg, grpc_error* error) {
+  Chttp2Connector* self = static_cast<Chttp2Connector*>(arg);
+  {
+    MutexLock lock(&self->mu_);
+    if (!self->notify_error_.has_value()) {
+      // The transport did not receive the settings frame in time. Destroy the
+      // transport.
+      grpc_endpoint_delete_from_pollset_set(self->endpoint_,
+                                            self->args_.interested_parties);
+      // TODO(yashykt): The following two lines should be moved to
+      // SubchannelConnector::Result::Reset()
+      grpc_transport_destroy(self->result_->transport);
+      grpc_channel_args_destroy(self->result_->channel_args);
+      self->result_->Reset();
+      self->MaybeNotify(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "connection attempt timed out before receiving SETTINGS frame"));
+    } else {
+      // OnReceiveSettings() was already invoked. Call Notify() again so that
+      // notify_ can be invoked.
+      self->MaybeNotify(GRPC_ERROR_NONE);
+    }
+  }
+  self->Unref();
+}
+
+void Chttp2Connector::MaybeNotify(grpc_error* error) {
+  if (notify_error_.has_value()) {
+    GRPC_ERROR_UNREF(error);
+    NullThenSchedClosure(DEBUG_LOCATION, &notify_, notify_error_.value());
+    // Clear state for a new Connect().
+    // Clear out the endpoint_, since it is the responsibility of
+    // the transport to shut it down.
+    endpoint_ = nullptr;
+    notify_error_.reset();
+  } else {
+    notify_error_ = error;
+  }
+}
+
 }  // namespace grpc_core

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -39,6 +39,19 @@ class Chttp2Connector : public SubchannelConnector {
   static void Connected(void* arg, grpc_error* error);
   void StartHandshakeLocked();
   static void OnHandshakeDone(void* arg, grpc_error* error);
+  static void OnReceiveSettings(void* arg, grpc_error* error);
+  static void OnTimeout(void* arg, grpc_error* error);
+
+  // We cannot invoke notify_ until both OnTimeout() and OnReceiveSettings()
+  // have been called since that is an indicator to the upper layer that we are
+  // done with the connection attempt. So, the notification process is broken
+  // into two steps. 1) Either OnTimeout() or OnReceiveSettings() gets invoked
+  // first. Whichever gets invoked, calls MaybeNotify() to set the result and
+  // triggers the other callback to be invoked. 2) When the other callback is
+  // invoked, we call MaybeNotify() again to actually invoke the notify_
+  // callback. Note that this only happens if the handshake is done and the
+  // connector is waiting on the SETTINGS frame.
+  void MaybeNotify(grpc_error* error);
 
   Mutex mu_;
   Args args_;
@@ -47,9 +60,13 @@ class Chttp2Connector : public SubchannelConnector {
   bool shutdown_ = false;
   bool connecting_ = false;
   // Holds the endpoint when first created before being handed off to
-  // the handshake manager.
+  // the handshake manager, and then again after handshake is done.
   grpc_endpoint* endpoint_ = nullptr;
   grpc_closure connected_;
+  grpc_closure on_receive_settings_;
+  grpc_timer timer_;
+  grpc_closure on_timeout_;
+  absl::optional<grpc_error*> notify_error_;
   RefCountedPtr<HandshakeManager> handshake_mgr_;
 };
 

data/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -33,11 +33,10 @@
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
-#include "src/core/lib/security/transport/target_authority_table.h"
-#include "src/core/lib/slice/slice_hash_table.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/transport/authority_override.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -75,39 +74,16 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
               "channel args.");
       return nullptr;
     }
-    // To which address are we connecting? By default, use the server URI.
-    const grpc_arg* server_uri_arg =
-        grpc_channel_args_find(args, GRPC_ARG_SERVER_URI);
-    const char* server_uri_str = grpc_channel_arg_get_string(server_uri_arg);
-    GPR_ASSERT(server_uri_str != nullptr);
-    grpc_uri* server_uri =
-        grpc_uri_parse(server_uri_str, true /* suppress errors */);
-    GPR_ASSERT(server_uri != nullptr);
-    const TargetAuthorityTable* target_authority_table =
-        FindTargetAuthorityTableInArgs(args);
-    grpc_core::UniquePtr<char> authority;
-    if (target_authority_table != nullptr) {
-      // Find the authority for the target.
-      const char* target_uri_str =
-          Subchannel::GetUriFromSubchannelAddressArg(args);
-      grpc_uri* target_uri =
-          grpc_uri_parse(target_uri_str, false /* suppress errors */);
-      GPR_ASSERT(target_uri != nullptr);
-      if (target_uri->path[0] != '\0') {  // "path" may be empty
-        const grpc_slice key = grpc_slice_from_static_string(
-            target_uri->path[0] == '/' ? target_uri->path + 1
-                                       : target_uri->path);
-        const grpc_core::UniquePtr<char>* value =
-            target_authority_table->Get(key);
-        if (value != nullptr) authority.reset(gpr_strdup(value->get()));
-        grpc_slice_unref_internal(key);
-      }
-      grpc_uri_destroy(target_uri);
-    }
-    // If the authority hasn't already been set (either because no target
-    // authority table was present or because the target was not present
-    // in the table), fall back to using the original server URI.
+    // Find the authority to use in the security connector.
+    // First, check the authority override channel arg.
+    // Otherwise, get it from the server name used to construct the
+    // channel.
+    grpc_core::UniquePtr<char> authority(
+        gpr_strdup(FindAuthorityOverrideInArgs(args)));
     if (authority == nullptr) {
+      const char* server_uri_str =
+          grpc_channel_args_find_string(args, GRPC_ARG_SERVER_URI);
+      GPR_ASSERT(server_uri_str != nullptr);
       authority = ResolverRegistry::GetDefaultAuthority(server_uri_str);
     }
     grpc_arg args_to_add[2];
@@ -120,7 +96,6 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
     }
     grpc_channel_args* args_with_authority =
         grpc_channel_args_copy_and_add(args, args_to_add, num_args_to_add);
-    grpc_uri_destroy(server_uri);
     // Create the security connector using the credentials and target name.
     grpc_channel_args* new_args_from_connector = nullptr;
     RefCountedPtr<grpc_channel_security_connector>

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -53,19 +53,19 @@
 namespace grpc_core {
 namespace {
 
-class Chttp2ServerListener : public ServerListenerInterface {
+class Chttp2ServerListener : public Server::ListenerInterface {
  public:
-  static grpc_error* Create(grpc_server* server, const char* addr,
+  static grpc_error* Create(Server* server, const char* addr,
                             grpc_channel_args* args, int* port_num);
 
-  static grpc_error* CreateWithAcceptor(grpc_server* server, const char* name,
+  static grpc_error* CreateWithAcceptor(Server* server, const char* name,
                                         grpc_channel_args* args);
 
   // Do not instantiate directly.  Use one of the factory methods above.
-  Chttp2ServerListener(grpc_server* server, grpc_channel_args* args);
+  Chttp2ServerListener(Server* server, grpc_channel_args* args);
   ~Chttp2ServerListener();
 
-  void Start(grpc_server* server,
+  void Start(Server* server,
              const std::vector<grpc_pollset*>* pollsets) override;
 
   channelz::ListenSocketNode* channelz_listen_socket_node() const override {
@@ -113,10 +113,10 @@ class Chttp2ServerListener : public ServerListenerInterface {
 
   static void TcpServerShutdownComplete(void* arg, grpc_error* error);
 
-  static void DestroyListener(grpc_server* /*server*/, void* arg,
+  static void DestroyListener(Server* /*server*/, void* arg,
                               grpc_closure* destroy_done);
 
-  grpc_server* const server_;
+  Server* const server_;
   grpc_channel_args* const args_;
   grpc_tcp_server* tcp_server_;
   Mutex mu_;
@@ -194,12 +194,10 @@ void Chttp2ServerListener::ConnectionState::OnHandshakeDone(void* arg,
   {
     MutexLock lock(&self->listener_->mu_);
     grpc_resource_user* resource_user =
-        grpc_server_get_default_resource_user(self->listener_->server_);
+        self->listener_->server_->default_resource_user();
     if (error != GRPC_ERROR_NONE || self->listener_->shutdown_) {
       const char* error_str = grpc_error_string(error);
       gpr_log(GPR_DEBUG, "Handshaking failed: %s", error_str);
-      grpc_resource_user* resource_user =
-          grpc_server_get_default_resource_user(self->listener_->server_);
       if (resource_user != nullptr) {
         grpc_resource_user_free(resource_user,
                                 GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
@@ -224,10 +222,9 @@ void Chttp2ServerListener::ConnectionState::OnHandshakeDone(void* arg,
       if (args->endpoint != nullptr) {
         grpc_transport* transport = grpc_create_chttp2_transport(
             args->args, args->endpoint, false, resource_user);
-        grpc_server_setup_transport(
-            self->listener_->server_, transport, self->accepting_pollset_,
-            args->args, grpc_chttp2_transport_get_socket_node(transport),
-            resource_user);
+        self->listener_->server_->SetupTransport(
+            transport, self->accepting_pollset_, args->args,
+            grpc_chttp2_transport_get_socket_node(transport), resource_user);
         // Use notify_on_receive_settings callback to enforce the
         // handshake deadline.
         // Note: The reinterpret_cast<>s here are safe, because
@@ -270,7 +267,7 @@ void Chttp2ServerListener::ConnectionState::OnHandshakeDone(void* arg,
 // Chttp2ServerListener
 //
 
-grpc_error* Chttp2ServerListener::Create(grpc_server* server, const char* addr,
+grpc_error* Chttp2ServerListener::Create(Server* server, const char* addr,
                                          grpc_channel_args* args,
                                          int* port_num) {
   std::vector<grpc_error*> error_list;
@@ -327,8 +324,7 @@ grpc_error* Chttp2ServerListener::Create(grpc_server* server, const char* addr,
               addr, absl::StrFormat("chttp2 listener %s", addr));
     }
     /* Register with the server only upon success */
-    grpc_server_add_listener(server,
-                             OrphanablePtr<ServerListenerInterface>(listener));
+    server->AddListener(OrphanablePtr<Server::ListenerInterface>(listener));
     return GRPC_ERROR_NONE;
   }();
   if (resolved != nullptr) {
@@ -352,7 +348,7 @@ grpc_error* Chttp2ServerListener::Create(grpc_server* server, const char* addr,
   return error;
 }
 
-grpc_error* Chttp2ServerListener::CreateWithAcceptor(grpc_server* server,
+grpc_error* Chttp2ServerListener::CreateWithAcceptor(Server* server,
                                                      const char* name,
                                                      grpc_channel_args* args) {
   Chttp2ServerListener* listener = new Chttp2ServerListener(server, args);
@@ -366,12 +362,11 @@ grpc_error* Chttp2ServerListener::CreateWithAcceptor(grpc_server* server,
   TcpServerFdHandler** arg_val =
       grpc_channel_args_find_pointer<TcpServerFdHandler*>(args, name);
   *arg_val = grpc_tcp_server_create_fd_handler(listener->tcp_server_);
-  grpc_server_add_listener(server,
-                           OrphanablePtr<ServerListenerInterface>(listener));
+  server->AddListener(OrphanablePtr<Server::ListenerInterface>(listener));
   return GRPC_ERROR_NONE;
 }
 
-Chttp2ServerListener::Chttp2ServerListener(grpc_server* server,
+Chttp2ServerListener::Chttp2ServerListener(Server* server,
                                            grpc_channel_args* args)
     : server_(server), args_(args) {
   GRPC_CLOSURE_INIT(&tcp_server_shutdown_complete_, TcpServerShutdownComplete,
@@ -383,7 +378,7 @@ Chttp2ServerListener::~Chttp2ServerListener() {
 }
 
 /* Server callback: start listening on our ports */
-void Chttp2ServerListener::Start(grpc_server* /*server*/,
+void Chttp2ServerListener::Start(Server* /*server*/,
                                  const std::vector<grpc_pollset*>* pollsets) {
   {
     MutexLock lock(&mu_);
@@ -400,8 +395,7 @@ void Chttp2ServerListener::SetOnDestroyDone(grpc_closure* on_destroy_done) {
 RefCountedPtr<HandshakeManager> Chttp2ServerListener::CreateHandshakeManager() {
   MutexLock lock(&mu_);
   if (shutdown_) return nullptr;
-  grpc_resource_user* resource_user =
-      grpc_server_get_default_resource_user(server_);
+  grpc_resource_user* resource_user = server_->default_resource_user();
   if (resource_user != nullptr &&
       !grpc_resource_user_safe_alloc(resource_user,
                                      GRPC_RESOURCE_QUOTA_CHANNEL_SIZE)) {
@@ -475,7 +469,7 @@ void Chttp2ServerListener::Orphan() {
 // Chttp2ServerAddPort()
 //
 
-grpc_error* Chttp2ServerAddPort(grpc_server* server, const char* addr,
+grpc_error* Chttp2ServerAddPort(Server* server, const char* addr,
                                 grpc_channel_args* args, int* port_num) {
   if (strncmp(addr, "external:", 9) == 0) {
     return grpc_core::Chttp2ServerListener::CreateWithAcceptor(server, addr,

data/src/core/ext/transport/chttp2/server/chttp2_server.h

@@ -24,12 +24,13 @@
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/surface/server.h"
 
 namespace grpc_core {
 
 /// Adds a port to \a server.  Sets \a port_num to the port number.
 /// Takes ownership of \a args.
-grpc_error* Chttp2ServerAddPort(grpc_server* server, const char* addr,
+grpc_error* Chttp2ServerAddPort(Server* server, const char* addr,
                                 grpc_channel_args* args, int* port_num);
 
 }  // namespace grpc_core

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2.cc

@@ -33,8 +33,8 @@ int grpc_server_add_insecure_http2_port(grpc_server* server, const char* addr) {
   GRPC_API_TRACE("grpc_server_add_insecure_http2_port(server=%p, addr=%s)", 2,
                  (server, addr));
   grpc_error* err = grpc_core::Chttp2ServerAddPort(
-      server, addr,
-      grpc_channel_args_copy(grpc_server_get_channel_args(server)), &port_num);
+      server->core_server.get(), addr,
+      grpc_channel_args_copy(server->core_server->channel_args()), &port_num);
   if (err != GRPC_ERROR_NONE) {
     const char* msg = grpc_error_string(err);
     gpr_log(GPR_ERROR, "%s", msg);

data/src/core/ext/transport/chttp2/server/insecure/server_chttp2_posix.cc

@@ -41,21 +41,21 @@ void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
   GPR_ASSERT(reserved == nullptr);
 
   grpc_core::ExecCtx exec_ctx;
+  grpc_core::Server* core_server = server->core_server.get();
 
+  const grpc_channel_args* server_args = core_server->channel_args();
   std::string name = absl::StrCat("fd:", fd);
-  grpc_endpoint* server_endpoint =
-      grpc_tcp_create(grpc_fd_create(fd, name.c_str(), true),
-                      grpc_server_get_channel_args(server), name.c_str());
+  grpc_endpoint* server_endpoint = grpc_tcp_create(
+      grpc_fd_create(fd, name.c_str(), true), server_args, name.c_str());
 
-  const grpc_channel_args* server_args = grpc_server_get_channel_args(server);
   grpc_transport* transport = grpc_create_chttp2_transport(
       server_args, server_endpoint, false /* is_client */);
 
-  for (grpc_pollset* pollset : grpc_server_get_pollsets(server)) {
+  for (grpc_pollset* pollset : core_server->pollsets()) {
     grpc_endpoint_add_to_pollset(server_endpoint, pollset);
   }
 
-  grpc_server_setup_transport(server, transport, nullptr, server_args, nullptr);
+  core_server->SetupTransport(transport, nullptr, server_args, nullptr);
   grpc_chttp2_transport_start_reading(transport, nullptr, nullptr);
 }