grpc 1.72.0 → 1.73.0

data/src/core/ext/transport/chttp2/chttp2_plugin.cc

@@ -0,0 +1,40 @@
+// Copyright 2025 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 "src/core/config/core_configuration.h"
+#include "src/core/ext/transport/chttp2/client/chttp2_connector.h"
+#include "src/core/ext/transport/chttp2/server/chttp2_server.h"
+#include "src/core/transport/endpoint_transport.h"
+
+namespace grpc_core {
+namespace {
+class Chttp2Transport final : public EndpointTransport {
+ public:
+  absl::StatusOr<grpc_channel*> ChannelCreate(
+      std::string target, const ChannelArgs& args) override {
+    return CreateHttp2Channel(target, args);
+  }
+
+  absl::StatusOr<int> AddPort(Server* server, std::string addr,
+                              const ChannelArgs& args) override {
+    return Chttp2ServerAddPort(server, addr.c_str(), args);
+  }
+};
+}  // namespace
+
+void RegisterChttp2Transport(CoreConfiguration::Builder* builder) {
+  builder->endpoint_transport_registry()->RegisterTransport(
+      "h2", std::make_unique<Chttp2Transport>());
+}
+}  // namespace grpc_core

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

@@ -64,6 +64,7 @@
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/resolver/resolver_registry.h"
+#include "src/core/transport/endpoint_transport_client_channel_factory.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/status_helper.h"
@@ -145,8 +146,6 @@ void Chttp2Connector::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
     result_->transport = grpc_create_chttp2_transport(
         (*result)->args, std::move((*result)->endpoint), true);
     CHECK_NE(result_->transport, nullptr);
-    result_->socket_node =
-        grpc_chttp2_transport_get_socket_node(result_->transport);
     result_->channel_args = std::move((*result)->args);
     Ref().release();  // Ref held by OnReceiveSettings()
     GRPC_CLOSURE_INIT(&on_receive_settings_, OnReceiveSettings, this,
@@ -225,121 +224,21 @@ void Chttp2Connector::MaybeNotify(grpc_error_handle error) {
   }
 }
 
-namespace {
-
-class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
- public:
-  RefCountedPtr<Subchannel> CreateSubchannel(
-      const grpc_resolved_address& address, const ChannelArgs& args) override {
-    absl::StatusOr<ChannelArgs> new_args = GetSecureNamingChannelArgs(args);
-    if (!new_args.ok()) {
-      LOG(ERROR) << "Failed to create channel args during subchannel creation: "
-                 << new_args.status() << "; Got args: " << args.ToString();
-      return nullptr;
-    }
-    RefCountedPtr<Subchannel> s = Subchannel::Create(
-        MakeOrphanable<Chttp2Connector>(), address, *new_args);
-    return s;
-  }
-
- private:
-  static absl::StatusOr<ChannelArgs> GetSecureNamingChannelArgs(
-      ChannelArgs args) {
-    auto* channel_credentials = args.GetObject<grpc_channel_credentials>();
-    if (channel_credentials == nullptr) {
-      return absl::InternalError("channel credentials missing for channel");
-    }
-    // Make sure security connector does not already exist in args.
-    if (args.Contains(GRPC_ARG_SECURITY_CONNECTOR)) {
-      return absl::InternalError(
-          "security connector already present in channel args.");
-    }
-    // Find the authority to use in the security connector.
-    std::optional<std::string> authority =
-        args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY);
-    if (!authority.has_value()) {
-      return absl::InternalError("authority not present in channel args");
-    }
-    // Create the security connector using the credentials and target name.
-    RefCountedPtr<grpc_channel_security_connector>
-        subchannel_security_connector =
-            channel_credentials->create_security_connector(
-                /*call_creds=*/nullptr, authority->c_str(), &args);
-    if (subchannel_security_connector == nullptr) {
-      return absl::InternalError(absl::StrFormat(
-          "Failed to create subchannel for secure name '%s'", *authority));
-    }
-    return args.SetObject(std::move(subchannel_security_connector));
-  }
-};
-
-absl::StatusOr<RefCountedPtr<Channel>> CreateChannel(const char* target,
-                                                     const ChannelArgs& args) {
-  if (target == nullptr) {
-    LOG(ERROR) << "cannot create channel with NULL target name";
-    return absl::InvalidArgumentError("channel target is NULL");
+absl::StatusOr<grpc_channel*> CreateHttp2Channel(std::string target,
+                                                 const ChannelArgs& args) {
+  auto r = ChannelCreate(
+      target,
+      args.SetObject(EndpointTransportClientChannelFactory<Chttp2Connector>()),
+      GRPC_CLIENT_CHANNEL, nullptr);
+  if (r.ok()) {
+    return r->release()->c_ptr();
+  } else {
+    return r.status();
   }
-  return ChannelCreate(target, args, GRPC_CLIENT_CHANNEL, nullptr);
 }
 
-}  // namespace
 }  // namespace grpc_core
 
-namespace {
-
-grpc_core::Chttp2SecureClientChannelFactory* g_factory;
-gpr_once g_factory_once = GPR_ONCE_INIT;
-
-void FactoryInit() {
-  g_factory = new grpc_core::Chttp2SecureClientChannelFactory();
-}
-
-}  // namespace
-
-// Create a client channel:
-//   Asynchronously: - resolve target
-//                   - connect to it (trying alternatives as presented)
-//                   - perform handshakes
-grpc_channel* grpc_channel_create(const char* target,
-                                  grpc_channel_credentials* creds,
-                                  const grpc_channel_args* c_args) {
-  grpc_core::ExecCtx exec_ctx;
-  GRPC_TRACE_LOG(api, INFO)
-      << "grpc_channel_create(target=" << target << ", creds=" << (void*)creds
-      << ", args=" << (void*)c_args << ")";
-  grpc_channel* channel = nullptr;
-  grpc_error_handle error;
-  if (creds != nullptr) {
-    // Add channel args containing the client channel factory and channel
-    // credentials.
-    gpr_once_init(&g_factory_once, FactoryInit);
-    grpc_core::ChannelArgs args =
-        creds->update_arguments(grpc_core::CoreConfiguration::Get()
-                                    .channel_args_preconditioning()
-                                    .PreconditionChannelArgs(c_args)
-                                    .SetObject(creds->Ref())
-                                    .SetObject(g_factory));
-    // Create channel.
-    auto r = grpc_core::CreateChannel(target, args);
-    if (r.ok()) {
-      channel = r->release()->c_ptr();
-    } else {
-      error = absl_status_to_grpc_error(r.status());
-    }
-  }
-  if (channel == nullptr) {
-    intptr_t integer;
-    grpc_status_code status = GRPC_STATUS_INTERNAL;
-    if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
-                           &integer)) {
-      status = static_cast<grpc_status_code>(integer);
-    }
-    channel = grpc_lame_client_channel_create(
-        target, status, "Failed to create client channel");
-  }
-  return channel;
-}
-
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
 grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
                                           grpc_channel_credentials* creds,

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

@@ -72,6 +72,9 @@ class Chttp2Connector : public SubchannelConnector {
   RefCountedPtr<HandshakeManager> handshake_mgr_;
 };
 
+absl::StatusOr<grpc_channel*> CreateHttp2Channel(std::string target,
+                                                 const ChannelArgs& args);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_CLIENT_CHTTP2_CONNECTOR_H