grpc 1.81.1 → 1.83.0

data/src/core/server/server_config_selector_filter.cc

@@ -27,6 +27,7 @@
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/observable.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
@@ -37,7 +38,6 @@
 #include "src/core/util/latent_see.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
-#include "src/core/util/sync.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -46,11 +46,11 @@ namespace grpc_core {
 
 namespace {
 
-class ServerConfigSelectorFilter final
-    : public ImplementChannelFilter<ServerConfigSelectorFilter>,
-      public InternallyRefCounted<ServerConfigSelectorFilter> {
+class LegacyServerConfigSelectorFilter final
+    : public ImplementChannelFilter<LegacyServerConfigSelectorFilter>,
+      public InternallyRefCounted<LegacyServerConfigSelectorFilter> {
  public:
-  explicit ServerConfigSelectorFilter(
+  explicit LegacyServerConfigSelectorFilter(
       RefCountedPtr<ServerConfigSelectorProvider>
           server_config_selector_provider);
 
@@ -58,19 +58,20 @@ class ServerConfigSelectorFilter final
     return "server_config_selector_filter";
   }
 
-  ServerConfigSelectorFilter(const ServerConfigSelectorFilter&) = delete;
-  ServerConfigSelectorFilter& operator=(const ServerConfigSelectorFilter&) =
+  LegacyServerConfigSelectorFilter(const LegacyServerConfigSelectorFilter&) =
       delete;
+  LegacyServerConfigSelectorFilter& operator=(
+      const LegacyServerConfigSelectorFilter&) = delete;
 
-  static absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>> Create(
+  static absl::StatusOr<OrphanablePtr<LegacyServerConfigSelectorFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args);
 
   void Orphan() override;
 
   class Call {
    public:
-    absl::Status OnClientInitialMetadata(ClientMetadata& md,
-                                         ServerConfigSelectorFilter* filter);
+    absl::Status OnClientInitialMetadata(
+        ClientMetadata& md, LegacyServerConfigSelectorFilter* filter);
     static inline const NoInterceptor OnServerInitialMetadata;
     static inline const NoInterceptor OnServerTrailingMetadata;
     static inline const NoInterceptor OnClientToServerMessage;
@@ -89,7 +90,7 @@ class ServerConfigSelectorFilter final
       : public ServerConfigSelectorProvider::ServerConfigSelectorWatcher {
    public:
     explicit ServerConfigSelectorWatcher(
-        RefCountedPtr<ServerConfigSelectorFilter> filter)
+        RefCountedPtr<LegacyServerConfigSelectorFilter> filter)
         : filter_(filter) {}
     void OnServerConfigSelectorUpdate(
         absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
@@ -98,36 +99,35 @@ class ServerConfigSelectorFilter final
     }
 
    private:
-    RefCountedPtr<ServerConfigSelectorFilter> filter_;
+    RefCountedPtr<LegacyServerConfigSelectorFilter> filter_;
   };
 
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
+  std::shared_ptr<ServerConfigSelectorWatcher> watcher_;
   Mutex mu_;
   std::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
       config_selector_ ABSL_GUARDED_BY(mu_);
 };
 
-absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>>
-ServerConfigSelectorFilter::Create(const ChannelArgs& args,
-                                   ChannelFilter::Args) {
+absl::StatusOr<OrphanablePtr<LegacyServerConfigSelectorFilter>>
+LegacyServerConfigSelectorFilter::Create(const ChannelArgs& args,
+                                         ChannelFilter::Args) {
   ServerConfigSelectorProvider* server_config_selector_provider =
       args.GetObject<ServerConfigSelectorProvider>();
   if (server_config_selector_provider == nullptr) {
     return absl::UnknownError("No ServerConfigSelectorProvider object found");
   }
-  return MakeOrphanable<ServerConfigSelectorFilter>(
+  return MakeOrphanable<LegacyServerConfigSelectorFilter>(
       server_config_selector_provider->Ref());
 }
 
-ServerConfigSelectorFilter::ServerConfigSelectorFilter(
+LegacyServerConfigSelectorFilter::LegacyServerConfigSelectorFilter(
     RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider)
     : server_config_selector_provider_(
           std::move(server_config_selector_provider)) {
   GRPC_CHECK(server_config_selector_provider_ != nullptr);
-  auto server_config_selector_watcher =
-      std::make_unique<ServerConfigSelectorWatcher>(Ref());
-  auto config_selector = server_config_selector_provider_->Watch(
-      std::move(server_config_selector_watcher));
+  watcher_ = std::make_shared<ServerConfigSelectorWatcher>(Ref());
+  auto config_selector = server_config_selector_provider_->Watch(watcher_);
   MutexLock lock(&mu_);
   // It's possible for the watcher to have already updated config_selector_
   if (!config_selector_.has_value()) {
@@ -135,17 +135,17 @@ ServerConfigSelectorFilter::ServerConfigSelectorFilter(
   }
 }
 
-void ServerConfigSelectorFilter::Orphan() {
+void LegacyServerConfigSelectorFilter::Orphan() {
   if (server_config_selector_provider_ != nullptr) {
-    server_config_selector_provider_->CancelWatch();
+    server_config_selector_provider_->CancelWatch(std::move(watcher_));
   }
   Unref();
 }
 
-absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
-    ClientMetadata& md, ServerConfigSelectorFilter* filter) {
+absl::Status LegacyServerConfigSelectorFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, LegacyServerConfigSelectorFilter* filter) {
   GRPC_LATENT_SEE_SCOPE(
-      "ServerConfigSelectorFilter::Call::OnClientInitialMetadata");
+      "LegacyServerConfigSelectorFilter::Call::OnClientInitialMetadata");
   auto sel = filter->config_selector();
   if (!sel.ok()) return sel.status();
   auto call_config = sel.value()->GetCallConfig(&md);
@@ -161,6 +161,115 @@ absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
 
 }  // namespace
 
+const grpc_channel_filter kLegacyServerConfigSelectorFilter =
+    MakePromiseBasedFilter<LegacyServerConfigSelectorFilter,
+                           FilterEndpoint::kServer>();
+
+namespace {
+
+class ServerConfigSelectorFilter final
+    : public ImplementChannelFilter<ServerConfigSelectorFilter>,
+      public InternallyRefCounted<ServerConfigSelectorFilter> {
+ public:
+  class Call {
+   public:
+    ArenaPromise<absl::Status> OnClientInitialMetadata(
+        ClientMetadata& md, ServerConfigSelectorFilter* filter);
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
+  };
+
+  static absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args) {
+    auto server_config_selector_provider =
+        args.GetObjectRef<ServerConfigSelectorProvider>();
+    if (server_config_selector_provider == nullptr) {
+      return absl::UnknownError("No ServerConfigSelectorProvider object found");
+    }
+    return MakeOrphanable<ServerConfigSelectorFilter>(
+        std::move(server_config_selector_provider));
+  }
+
+  explicit ServerConfigSelectorFilter(
+      RefCountedPtr<ServerConfigSelectorProvider>
+          server_config_selector_provider)
+      : server_config_selector_provider_(
+            std::move(server_config_selector_provider)),
+        config_selector_(nullptr) {
+    watcher_ = std::make_shared<ServerConfigSelectorWatcher>(Ref());
+    // TODO(roth): Remove the void cast when removing the
+    // xds_server_filter_chain_per_route experiment.
+    (void)server_config_selector_provider_->Watch(watcher_);
+  }
+
+  ServerConfigSelectorFilter(const ServerConfigSelectorFilter&) = delete;
+  ServerConfigSelectorFilter& operator=(const ServerConfigSelectorFilter&) =
+      delete;
+
+  void Orphan() override {
+    if (server_config_selector_provider_ != nullptr) {
+      server_config_selector_provider_->CancelWatch(std::move(watcher_));
+    }
+    Unref();
+  }
+
+  static absl::string_view TypeName() {
+    return "server_config_selector_filter";
+  }
+
+ private:
+  class ServerConfigSelectorWatcher
+      : public ServerConfigSelectorProvider::ServerConfigSelectorWatcher {
+   public:
+    explicit ServerConfigSelectorWatcher(
+        RefCountedPtr<ServerConfigSelectorFilter> filter)
+        : filter_(filter) {}
+    void OnServerConfigSelectorUpdate(
+        absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
+      // TODO(roth): Build filter chains here.
+      filter_->config_selector_.Set(std::move(update));
+    }
+
+   private:
+    RefCountedPtr<ServerConfigSelectorFilter> filter_;
+  };
+
+  RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
+  std::shared_ptr<ServerConfigSelectorWatcher> watcher_;
+  Observable<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+      config_selector_;
+};
+
+ArenaPromise<absl::Status>
+ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, ServerConfigSelectorFilter* filter) {
+  GRPC_LATENT_SEE_SCOPE(
+      "ServerConfigSelectorFilter::Call::OnClientInitialMetadata");
+  return TrySeq(
+      filter->config_selector_.Next(nullptr),
+      [&md](
+          absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector) {
+        if (!config_selector.ok()) return config_selector.status();
+        auto call_config = (*config_selector)->GetCallConfig(&md);
+        if (!call_config.ok()) {
+          return absl::UnavailableError(StatusToString(call_config.status()));
+        }
+        auto* arena = GetContext<Arena>();
+        auto* service_config_call_data =
+            arena->New<ServiceConfigCallData>(arena);
+        service_config_call_data->SetServiceConfig(
+            std::move(call_config->service_config),
+            call_config->method_configs);
+        return absl::OkStatus();
+      });
+}
+
+}  // namespace
+
 const grpc_channel_filter kServerConfigSelectorFilter =
     MakePromiseBasedFilter<ServerConfigSelectorFilter,
                            FilterEndpoint::kServer>();

data/src/core/server/server_config_selector_filter.h

@@ -26,6 +26,7 @@
 
 namespace grpc_core {
 
+extern const grpc_channel_filter kLegacyServerConfigSelectorFilter;
 extern const grpc_channel_filter kServerConfigSelectorFilter;
 
 }  // namespace grpc_core