grpc 1.81.1 → 1.82.0.pre1

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -19,102 +19,22 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/status.h>
 #include <grpc/support/port_platform.h>
-#include <inttypes.h>
 
-#include <functional>
-#include <utility>
-
-#include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/latch.h"
-#include "src/core/lib/promise/race.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/transport.h"
-#include "src/core/service_config/service_config_call_data.h"
+#include "src/core/transport/message_size_service_config.h"
 #include "src/core/util/latent_see.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 
 namespace grpc_core {
 
-//
-// MessageSizeParsedConfig
-//
-
-const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
-    Arena* arena, size_t service_config_parser_index) {
-  auto* svc_cfg_call_data = arena->GetContext<ServiceConfigCallData>();
-  if (svc_cfg_call_data == nullptr) return nullptr;
-  return static_cast<const MessageSizeParsedConfig*>(
-      svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index));
-}
-
-MessageSizeParsedConfig MessageSizeParsedConfig::GetFromChannelArgs(
-    const ChannelArgs& channel_args) {
-  MessageSizeParsedConfig limits;
-  limits.max_send_size_ = GetMaxSendSizeFromChannelArgs(channel_args);
-  limits.max_recv_size_ = GetMaxRecvSizeFromChannelArgs(channel_args);
-  return limits;
-}
-
-std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return std::nullopt;
-  int size = args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
-                 .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH);
-  if (size < 0) return std::nullopt;
-  return static_cast<uint32_t>(size);
-}
-
-std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return std::nullopt;
-  int size = args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
-                 .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
-  if (size < 0) return std::nullopt;
-  return static_cast<uint32_t>(size);
-}
-
-const JsonLoaderInterface* MessageSizeParsedConfig::JsonLoader(
-    const JsonArgs&) {
-  static const auto* loader =
-      JsonObjectLoader<MessageSizeParsedConfig>()
-          .OptionalField("maxRequestMessageBytes",
-                         &MessageSizeParsedConfig::max_send_size_)
-          .OptionalField("maxResponseMessageBytes",
-                         &MessageSizeParsedConfig::max_recv_size_)
-          .Finish();
-  return loader;
-}
-
-//
-// MessageSizeParser
-//
-
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-MessageSizeParser::ParsePerMethodParams(const ChannelArgs& /*args*/,
-                                        const Json& json,
-                                        ValidationErrors* errors) {
-  return LoadFromJson<std::unique_ptr<MessageSizeParsedConfig>>(
-      json, JsonArgs(), errors);
-}
-
-void MessageSizeParser::Register(CoreConfiguration::Builder* builder) {
-  builder->service_config_parser()->RegisterParser(
-      std::make_unique<MessageSizeParser>());
-}
-
-size_t MessageSizeParser::ParserIndex() {
-  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
-      parser_name());
-}
-
 //
 // MessageSizeFilter
 //

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -24,64 +24,15 @@
 #include <memory>
 #include <optional>
 
-#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
-#include "src/core/lib/promise/arena_promise.h"
-#include "src/core/lib/transport/transport.h"
-#include "src/core/service_config/service_config_parser.h"
-#include "src/core/util/json/json.h"
-#include "src/core/util/json/json_args.h"
-#include "src/core/util/json/json_object_loader.h"
-#include "src/core/util/validation_errors.h"
+#include "src/core/transport/message_size_service_config.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
-class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
- public:
-  std::optional<uint32_t> max_send_size() const { return max_send_size_; }
-  std::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
-
-  MessageSizeParsedConfig() = default;
-
-  MessageSizeParsedConfig(std::optional<uint32_t> max_send_size,
-                          std::optional<uint32_t> max_recv_size)
-      : max_send_size_(max_send_size), max_recv_size_(max_recv_size) {}
-
-  static const MessageSizeParsedConfig* GetFromCallContext(
-      Arena* arena, size_t service_config_parser_index);
-
-  static MessageSizeParsedConfig GetFromChannelArgs(const ChannelArgs& args);
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-
- private:
-  std::optional<uint32_t> max_send_size_;
-  std::optional<uint32_t> max_recv_size_;
-};
-
-class MessageSizeParser : public ServiceConfigParser::Parser {
- public:
-  absl::string_view name() const override { return parser_name(); }
-
-  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const ChannelArgs& /*args*/, const Json& json,
-      ValidationErrors* errors) override;
-
-  static void Register(CoreConfiguration::Builder* builder);
-
-  static size_t ParserIndex();
-
- private:
-  static absl::string_view parser_name() { return "message_size"; }
-};
-
-std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
-std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
-
 class ServerMessageSizeFilter final
     : public ImplementChannelFilter<ServerMessageSizeFilter> {
  public:

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -29,7 +29,6 @@
 
 #include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
-#include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/context.h"
@@ -85,24 +84,19 @@ const grpc_channel_filter StatefulSessionFilter::kFilterVtable =
 absl::StatusOr<std::unique_ptr<StatefulSessionFilter>>
 StatefulSessionFilter::Create(const ChannelArgs&,
                               ChannelFilter::Args filter_args) {
-  if (IsXdsChannelFilterChainPerRouteEnabled()) {
-    if (filter_args.config() == nullptr) {
-      return absl::InternalError("no config in stateful session filter");
-    }
-    if (filter_args.config()->type() != Config::Type()) {
-      return absl::InternalError(
-          absl::StrCat("wrong config type in stateful session filter: ",
-                       filter_args.config()->type().name()));
-    }
+  if (filter_args.config() == nullptr) {
+    return absl::InternalError("no config in stateful session filter");
+  }
+  if (filter_args.config()->type() != Config::Type()) {
+    return absl::InternalError(
+        absl::StrCat("wrong config type in stateful session filter: ",
+                     filter_args.config()->type().name()));
   }
   return std::make_unique<StatefulSessionFilter>(filter_args);
 }
 
 StatefulSessionFilter::StatefulSessionFilter(ChannelFilter::Args filter_args)
-    : index_(filter_args.instance_id()),
-      service_config_parser_index_(
-          StatefulSessionServiceConfigParser::ParserIndex()),
-      config_(filter_args.config().TakeAsSubclass<const Config>()) {}
+    : config_(filter_args.config().TakeAsSubclass<const Config>()) {}
 
 namespace {
 
@@ -121,12 +115,9 @@ absl::string_view AllocateStringOnArena(
 }
 
 // Adds the set-cookie header to the server initial metadata if needed.
-// TODO(roth): Un-templatize this when we remove the
-// xds_channel_filter_chain_per_route experiment.
-template <typename T>
 void MaybeUpdateServerInitialMetadata(
-    const T& config, bool cluster_changed, absl::string_view actual_cluster,
-    absl::string_view cookie_address_list,
+    const StatefulSessionFilter::Config& config, bool cluster_changed,
+    absl::string_view actual_cluster, absl::string_view cookie_address_list,
     XdsOverrideHostAttribute* override_host_attribute,
     ServerMetadata& server_initial_metadata) {
   // If cookie doesn't need to change, do nothing.
@@ -246,30 +237,12 @@ bool IsConfiguredPath(absl::string_view configured_path,
 void StatefulSessionFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, StatefulSessionFilter* filter) {
   GRPC_LATENT_SEE_SCOPE("StatefulSessionFilter::Call::OnClientInitialMetadata");
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    // Get config.
-    auto* service_config_call_data = GetContext<ServiceConfigCallData>();
-    GRPC_CHECK_NE(service_config_call_data, nullptr);
-    auto* method_params = static_cast<StatefulSessionMethodParsedConfig*>(
-        service_config_call_data->GetMethodParsedConfig(
-            filter->service_config_parser_index_));
-    GRPC_CHECK_NE(method_params, nullptr);
-    cookie_config_ = method_params->GetConfig(filter->index_);
-    GRPC_CHECK_NE(cookie_config_, nullptr);
-    OnClientInitialMetadataImpl(md, *cookie_config_);
-    return;
-  }
-  OnClientInitialMetadataImpl(md, *filter->config_);
-}
-
-template <typename T>
-void StatefulSessionFilter::Call::OnClientInitialMetadataImpl(
-    ClientMetadata& md, const T& config) {
-  if (config.cookie_name.empty() || !IsConfiguredPath(config.path, md)) {
+  if (filter->config_->cookie_name.empty() ||
+      !IsConfiguredPath(filter->config_->path, md)) {
     return;
   }
   // Base64-decode cookie value.
-  std::string cookie_value = GetCookieValue(md, config.cookie_name);
+  std::string cookie_value = GetCookieValue(md, filter->config_->cookie_name);
   // Cookie format is "host;cluster"
   std::pair<absl::string_view, absl::string_view> host_cluster =
       absl::StrSplit(cookie_value, absl::MaxSplits(';', 1));
@@ -300,12 +273,6 @@ void StatefulSessionFilter::Call::OnServerInitialMetadata(
   GRPC_LATENT_SEE_SCOPE("StatefulSessionFilter::Call::OnServerInitialMetadata");
   if (!perform_filtering_) return;
   // Add cookie to server initial metadata if needed.
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    MaybeUpdateServerInitialMetadata(*cookie_config_, cluster_changed_,
-                                     cluster_name_, cookie_address_list_,
-                                     override_host_attribute_, md);
-    return;
-  }
   MaybeUpdateServerInitialMetadata(*filter->config_, cluster_changed_,
                                    cluster_name_, cookie_address_list_,
                                    override_host_attribute_, md);
@@ -320,20 +287,10 @@ void StatefulSessionFilter::Call::OnServerTrailingMetadata(
   // cookie to the trailing metadata instead of the
   // initial metadata.
   if (md.get(GrpcTrailersOnly()).value_or(false)) {
-    if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-      MaybeUpdateServerInitialMetadata(*cookie_config_, cluster_changed_,
-                                       cluster_name_, cookie_address_list_,
-                                       override_host_attribute_, md);
-      return;
-    }
     MaybeUpdateServerInitialMetadata(*filter->config_, cluster_changed_,
                                      cluster_name_, cookie_address_list_,
                                      override_host_attribute_, md);
   }
 }
 
-void StatefulSessionFilterRegister(CoreConfiguration::Builder* builder) {
-  StatefulSessionServiceConfigParser::Register(builder);
-}
-
 }  // namespace grpc_core

data/src/core/ext/filters/stateful_session/stateful_session_filter.h

@@ -22,7 +22,6 @@
 
 #include <utility>
 
-#include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
@@ -118,12 +117,6 @@ class StatefulSessionFilter
     }
 
    private:
-    // TODO(roth): Remove these when removing the
-    // xds_channel_filter_chain_per_route experiment.
-    template <typename T>
-    void OnClientInitialMetadataImpl(ClientMetadata& md, const T& config);
-    const StatefulSessionMethodParsedConfig::CookieConfig* cookie_config_;
-
     XdsOverrideHostAttribute* override_host_attribute_;
     absl::string_view cluster_name_;
     absl::string_view cookie_address_list_;
@@ -132,13 +125,6 @@ class StatefulSessionFilter
   };
 
  private:
-  // TODO(roth): Remove these fields when removing the
-  // xds_channel_filter_chain_per_route experiment.
-  // The relative index of instances of the same filter.
-  const size_t index_;
-  // Index of the service config parser.
-  const size_t service_config_parser_index_;
-
   const RefCountedPtr<const Config> config_;
 };
 

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

@@ -322,7 +322,7 @@ absl::StatusOr<grpc_channel*> CreateHttp2Channel(std::string target,
   // 8-15 months.
   const bool is_v3 = false;
 #else
-  const bool is_v3 = IsPromiseBasedHttp2ClientTransportEnabled();
+  const bool is_v3 = grpc_core::http2::ShouldEnablePh2Client();
 #endif  // GRPC_EXPERIMENTAL_TEMPORARILY_DISABLE_PH2
   auto r = ChannelCreate(
       target,

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

@@ -30,11 +30,13 @@
 #include <string.h>
 
 #include <algorithm>
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "src/core/channelz/channelz.h"
@@ -43,6 +45,7 @@
 #include "src/core/credentials/transport/security_connector.h"
 #include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/ext/transport/chttp2/transport/http2_server_transport.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/handshaker/handshaker.h"
@@ -70,8 +73,11 @@
 #include "src/core/lib/resource_quota/connection_quota.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/promise_endpoint.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/mitigation_engine/mitigation_engine.h"
 #include "src/core/server/server.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/grpc_check.h"
@@ -226,41 +232,97 @@ void NewChttp2ServerListener::ActiveConnection::HandshakingState::
   // code, so we can just clean up here without creating a transport.
   if (!connection_->shutdown_ && result.ok() &&
       (*result)->endpoint != nullptr) {
-    RefCountedPtr<Transport> transport =
-        grpc_create_chttp2_transport((*result)->args,
-                                     std::move((*result)->endpoint), false)
-            ->Ref();
-    grpc_error_handle channel_init_err =
-        connection_->listener_state_->server()->SetupTransport(
-            transport.get(), accepting_pollset_, (*result)->args);
-    if (channel_init_err.ok()) {
-      // Use notify_on_receive_settings callback to enforce the
-      // handshake deadline.
-      connection_->state_ =
-          DownCast<grpc_chttp2_transport*>(transport.get())->Ref();
-      grpc_closure* on_close = &connection_->on_close_;
-      // Refs held by OnClose()
-      connection_->Ref().release();
-      grpc_chttp2_transport_start_reading(
-          transport.get(), (*result)->read_buffer.c_slice_buffer(),
-          [self = Ref()](absl::StatusOr<uint32_t>) {
-            self->OnReceiveSettings();
-          },
-          nullptr, on_close);
-      timer_handle_ = connection_->listener_state_->event_engine()->RunAfter(
-          deadline_ - Timestamp::Now(), [self = Ref()]() mutable {
-            // HandshakingState deletion might require an active ExecCtx.
-            ExecCtx exec_ctx;
-            auto* self_ptr = self.get();
-            self_ptr->connection_->work_serializer_.Run(
-                [self = std::move(self)]() { self->OnTimeoutLocked(); },
-                DEBUG_LOCATION);
-          });
+    const bool is_callv3 =
+        (*result)->args.GetBool(GRPC_ARG_USE_V3_STACK).value_or(false);
+
+    if (!is_callv3) {
+      RefCountedPtr<Transport> transport =
+          grpc_create_chttp2_transport((*result)->args,
+                                       std::move((*result)->endpoint), false)
+              ->Ref();
+      grpc_error_handle channel_init_err =
+          connection_->listener_state_->server()->SetupTransport(
+              transport.get(), accepting_pollset_, (*result)->args);
+      if (channel_init_err.ok()) {
+        // Use notify_on_receive_settings callback to enforce the
+        // handshake deadline.
+        connection_->state_ =
+            DownCast<grpc_chttp2_transport*>(transport.get())->Ref();
+        grpc_closure* on_close = &connection_->on_close_;
+        // Refs held by OnClose()
+        connection_->Ref().release();
+        grpc_chttp2_transport_start_reading(
+            transport.get(), (*result)->read_buffer.c_slice_buffer(),
+            [self = Ref()](absl::StatusOr<uint32_t>) {
+              self->OnReceiveSettings();
+            },
+            nullptr, on_close);
+        timer_handle_ = connection_->listener_state_->event_engine()->RunAfter(
+            deadline_ - Timestamp::Now(), [self = Ref()]() mutable {
+              // HandshakingState deletion might require an active ExecCtx.
+              ExecCtx exec_ctx;
+              auto* self_ptr = self.get();
+              self_ptr->connection_->work_serializer_.Run(
+                  [self = std::move(self)]() { self->OnTimeoutLocked(); },
+                  DEBUG_LOCATION);
+            });
+      } else {
+        // Failed to create channel from transport. Clean up.
+        LOG(ERROR) << "Failed to create channel: "
+                   << StatusToString(channel_init_err);
+        transport->Orphan();
+      }
     } else {
-      // Failed to create channel from transport. Clean up.
-      LOG(ERROR) << "Failed to create channel: "
-                 << StatusToString(channel_init_err);
-      transport->Orphan();
+      std::unique_ptr<EventEngine::Endpoint> event_engine_endpoint =
+          grpc_event_engine::experimental::
+              grpc_take_wrapped_event_engine_endpoint(
+                  (*result)->endpoint.release());
+      if (GPR_UNLIKELY(event_engine_endpoint == nullptr)) {
+        LOG(ERROR) << "Failed to take endpoint.";
+      } else {
+        PromiseEndpoint promise_endpoint(std::move(event_engine_endpoint),
+                                         std::move((*result)->read_buffer));
+        std::shared_ptr<EventEngine> event_engine_ptr =
+            (*result)->args.GetObjectRef<EventEngine>();
+        // TODO(akshitpatel) : [PH2][P4] : Consider making on_close_
+        // absl::AnyInvocable.
+        grpc_closure* on_close = &connection_->on_close_;
+        // Refs held by OnClose()
+        connection_->Ref().release();
+        // Use notify_on_receive_settings callback to enforce the
+        // handshake deadline.
+        auto* ph2_transport = new http2::Http2ServerTransport(
+            std::move(promise_endpoint), (*result)->args,
+            std::move(event_engine_ptr),
+            [self = Ref()](absl::StatusOr<uint32_t>) {
+              self->OnReceiveSettings();
+            },
+            on_close);
+        // SetupTransport will spawn the initial transport promises.
+        grpc_error_handle channel_init_err =
+            connection_->listener_state_->server()->SetupTransport(
+                ph2_transport, accepting_pollset_, (*result)->args);
+        if (GPR_LIKELY(channel_init_err.ok())) {
+          ph2_transport->Ref().release();
+          connection_->state_ =
+              RefCountedPtr<http2::Http2ServerTransport>(ph2_transport);
+          timer_handle_ =
+              connection_->listener_state_->event_engine()->RunAfter(
+                  deadline_ - Timestamp::Now(), [self = Ref()]() mutable {
+                    // HandshakingState deletion might require an active
+                    // ExecCtx.
+                    ExecCtx exec_ctx;
+                    auto* self_ptr = self.get();
+                    self_ptr->connection_->work_serializer_.Run(
+                        [self = std::move(self)]() { self->OnTimeoutLocked(); },
+                        DEBUG_LOCATION);
+                  });
+        } else {
+          LOG(ERROR) << "Failed to create channel: "
+                     << StatusToString(channel_init_err);
+          ph2_transport->Orphan();
+        }
+      }
     }
   }
   // Since the handshake manager is done, the connection no longer needs to
@@ -269,6 +331,8 @@ void NewChttp2ServerListener::ActiveConnection::HandshakingState::
   connection_->listener_state_->OnHandshakeDone(connection_.get());
   // Clean up if we don't have a transport
   if (!std::holds_alternative<RefCountedPtr<grpc_chttp2_transport>>(
+          connection_->state_) &&
+      !std::holds_alternative<RefCountedPtr<http2::Http2ServerTransport>>(
           connection_->state_)) {
     connection_->listener_state_->connection_quota()->ReleaseConnections(1);
     connection_->listener_state_->RemoveLogicalConnection(connection_.get());
@@ -373,6 +437,12 @@ void NewChttp2ServerListener::ActiveConnection::SendGoAwayImplLocked() {
                 static_cast<intptr_t>(Http2ErrorCode::kNoError));
             transport->PerformOp(op);
           }
+        },
+        [](GRPC_UNUSED const RefCountedPtr<http2::Http2ServerTransport>&
+               transport) {
+          // TODO(akshitpatel) [PH2][P0] : Add support for GOAWAY for
+          // Http2ServerTransport.
+          LOG(FATAL) << "Not implemented";
         });
   }
 }
@@ -397,6 +467,12 @@ void NewChttp2ServerListener::ActiveConnection::
               "Drain grace time expired. Closing connection immediately.");
           transport->PerformOp(op);
         }
+      },
+      [](GRPC_UNUSED const RefCountedPtr<http2::Http2ServerTransport>&
+             transport) {
+        // TODO(akshitpatel) [PH2][P0] : Add support for disconnect immediately
+        // for Http2ServerTransport.
+        LOG(FATAL) << "Not implemented";
       });
 }
 
@@ -546,11 +622,21 @@ void NewChttp2ServerListener::OnAccept(
   NewChttp2ServerListener* self = static_cast<NewChttp2ServerListener*>(arg);
   OrphanablePtr<grpc_endpoint> endpoint(tcp);
   AcceptorPtr acceptor(server_acceptor);
+  absl::string_view peer = grpc_endpoint_get_peer(endpoint.get());
   if (!self->listener_state_->connection_quota()->AllowIncomingConnection(
-          self->listener_state_->memory_quota(),
-          grpc_endpoint_get_peer(endpoint.get()))) {
+          self->listener_state_->memory_quota(), peer)) {
     return;
   }
+  RefCountedPtr<MitigationEngine> mitigation_engine = self->mitigation_engine();
+  if (mitigation_engine != nullptr) {
+    auto action = mitigation_engine->EvaluateIncomingConnection(peer);
+    if (action == MitigationEngine::Action::kCloseConnection) {
+      LOG_EVERY_N_SEC(INFO, 60)
+          << "Mitigation engine rejected connection from " << peer;
+      self->listener_state_->connection_quota()->ReleaseConnections(1);
+      return;
+    }
+  }
   {
     // The ref for the tcp_server need to be taken in the critical region
     // after having made sure that the listener has not been Orphaned, so as
@@ -615,8 +701,12 @@ absl::StatusOr<int> Chttp2ServerAddPort(Server* server, const char* addr,
   if (addr == nullptr) {
     return GRPC_ERROR_CREATE("Invalid address: addr cannot be a nullptr.");
   }
+
+  ChannelArgs updated_args =
+      args.Set(GRPC_ARG_USE_V3_STACK, http2::ShouldEnablePh2Server());
   if (strncmp(addr, "external:", 9) == 0) {
-    auto r = NewChttp2ServerListener::CreateWithAcceptor(server, addr, args);
+    auto r =
+        NewChttp2ServerListener::CreateWithAcceptor(server, addr, updated_args);
     if (!r.ok()) return r;
     return -1;
   }
@@ -683,7 +773,8 @@ absl::StatusOr<int> Chttp2ServerAddPort(Server* server, const char* addr,
         grpc_event_engine::experimental::ResolvedAddressSetPort(addr, port_num);
       }
       int port_temp = -1;
-      error = NewChttp2ServerListener::Create(server, addr, args, &port_temp);
+      error = NewChttp2ServerListener::Create(server, addr, updated_args,
+                                              &port_temp);
       if (!error.ok()) {
         error_list.push_back(error);
       } else {
@@ -778,7 +869,10 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
   grpc_core::ExecCtx exec_ctx;
   grpc_core::Server* core_server = grpc_core::Server::FromC(server);
 
-  grpc_core::ChannelArgs server_args = core_server->channel_args();
+  const bool is_callv3 = grpc_core::http2::ShouldEnablePh2Server();
+  grpc_core::ChannelArgs server_args =
+      core_server->channel_args().Set(GRPC_ARG_USE_V3_STACK, is_callv3);
+
   std::string name = absl::StrCat("fd:", fd);
   auto memory_quota =
       server_args.GetObject<grpc_core::ResourceQuota>()->memory_quota();
@@ -791,18 +885,46 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
   for (grpc_pollset* pollset : core_server->pollsets()) {
     grpc_endpoint_add_to_pollset(server_endpoint.get(), pollset);
   }
-  grpc_core::Transport* transport = grpc_create_chttp2_transport(
-      server_args, std::move(server_endpoint), false  // is_client
-  );
-  grpc_error_handle error =
-      core_server->SetupTransport(transport, nullptr, server_args);
-  if (error.ok()) {
-    grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr,
-                                        nullptr);
+
+  if (!is_callv3) {
+    grpc_core::Transport* transport = grpc_create_chttp2_transport(
+        server_args, std::move(server_endpoint), false  // is_client
+    );
+    grpc_error_handle error =
+        core_server->SetupTransport(transport, nullptr, server_args);
+    if (error.ok()) {
+      grpc_chttp2_transport_start_reading(transport, nullptr, nullptr, nullptr,
+                                          nullptr);
+    } else {
+      LOG(ERROR) << "Failed to create channel: "
+                 << grpc_core::StatusToString(error);
+      transport->Orphan();
+    }
   } else {
-    LOG(ERROR) << "Failed to create channel: "
-               << grpc_core::StatusToString(error);
-    transport->Orphan();
+    std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        event_engine_endpoint = grpc_event_engine::experimental::
+            grpc_take_wrapped_event_engine_endpoint(server_endpoint.release());
+    if (event_engine_endpoint != nullptr) {
+      grpc_core::PromiseEndpoint promise_endpoint(
+          std::move(event_engine_endpoint), grpc_core::SliceBuffer());
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine_ptr = server_args.GetObjectRef<grpc_core::EventEngine>();
+      grpc_core::Transport* transport =
+          new grpc_core::http2::Http2ServerTransport(
+              std::move(promise_endpoint), server_args,
+              std::move(event_engine_ptr), [](absl::StatusOr<uint32_t>) {},
+              /*on_close_callback=*/nullptr);
+      grpc_error_handle error =
+          core_server->SetupTransport(transport, nullptr, server_args);
+      // SetupTransport will spawn the initial transport promises.
+      if (!error.ok()) {
+        LOG(ERROR) << "Failed to create channel: "
+                   << grpc_core::StatusToString(error);
+        transport->Orphan();
+      }
+    } else {
+      LOG(ERROR) << "Failed to take endpoint.";
+    }
   }
 }
 
@@ -836,7 +958,9 @@ absl::Status grpc_server_add_passive_listener(
   }
   auto args = server->channel_args()
                   .SetObject(credentials->Ref())
-                  .SetObject(std::move(sc));
+                  .SetObject(std::move(sc))
+                  .Set(GRPC_ARG_USE_V3_STACK,
+                       grpc_core::http2::ShouldEnablePh2Server());
   passive_listener->listener_ =
       grpc_core::NewChttp2ServerListener::CreateForPassiveListener(
           server, args, passive_listener);