grpc 1.51.0 → 1.52.0.pre2

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -0,0 +1,132 @@
+//
+//
+// Copyright 2020 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.
+//
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "absl/status/statusor.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/compression_types.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/compression/compression_internal.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+/// Compression filter for messages.
+///
+/// See <grpc/compression.h> for the available compression settings.
+///
+/// Compression settings may come from:
+/// - Channel configuration, as established at channel creation time.
+/// - The metadata accompanying the outgoing data to be compressed. This is
+///   taken as a request only. We may choose not to honor it. The metadata key
+///   is given by \a GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY.
+///
+/// Compression can be disabled for concrete messages (for instance in order to
+/// prevent CRIME/BEAST type attacks) by having the GRPC_WRITE_NO_COMPRESS set
+/// in the MessageHandle flags.
+///
+/// The attempted compression mechanism is added to the resulting initial
+/// metadata under the 'grpc-encoding' key.
+///
+/// If compression is actually performed, the MessageHandle's flag is modified
+/// to incorporate GRPC_WRITE_INTERNAL_COMPRESS. Otherwise, and regardless of
+/// the aforementioned 'grpc-encoding' metadata value, data will pass through
+/// uncompressed.
+
+class CompressionFilter : public ChannelFilter {
+ protected:
+  explicit CompressionFilter(const ChannelArgs& args);
+
+  class CompressLoop;
+  class DecompressLoop;
+
+  grpc_compression_algorithm default_compression_algorithm() const {
+    return default_compression_algorithm_;
+  }
+
+  CompressionAlgorithmSet enabled_compression_algorithms() const {
+    return enabled_compression_algorithms_;
+  }
+
+ private:
+  // Compress one message synchronously.
+  MessageHandle CompressMessage(MessageHandle message,
+                                grpc_compression_algorithm algorithm) const;
+  // Decompress one message synchronously.
+  absl::StatusOr<MessageHandle> DecompressMessage(
+      MessageHandle message, grpc_compression_algorithm algorithm,
+      absl::optional<uint32_t> max_recv_message_length) const;
+
+  // Max receive message length, if set.
+  absl::optional<uint32_t> max_recv_size_;
+  size_t message_size_service_config_parser_index_;
+  // The default, channel-level, compression algorithm.
+  grpc_compression_algorithm default_compression_algorithm_;
+  // Enabled compression algorithms.
+  CompressionAlgorithmSet enabled_compression_algorithms_;
+  // Is compression enabled?
+  bool enable_compression_;
+  // Is decompression enabled?
+  bool enable_decompression_;
+};
+
+class ClientCompressionFilter final : public CompressionFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ClientCompressionFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  using CompressionFilter::CompressionFilter;
+};
+
+class ServerCompressionFilter final : public CompressionFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ServerCompressionFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  using CompressionFilter::CompressionFilter;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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 <grpc/support/port_platform.h>
 
@@ -29,7 +29,7 @@
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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.
+//
+//
 
 #ifndef GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
 #define GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
@@ -60,4 +60,4 @@ class HttpServerFilter : public ChannelFilter {
   "grpc.http.do_not_use_unless_you_have_permission_from_grpc_team_allow_"                       \
   "broken_put_requests"
 
-#endif /* GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H */
+#endif  // GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H

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

@@ -23,7 +23,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
@@ -210,11 +210,11 @@ static void recv_message_ready(void* user_data, grpc_error_handle error) {
   grpc_closure* closure = calld->next_recv_message_ready;
   calld->next_recv_message_ready = nullptr;
   if (calld->seen_recv_trailing_metadata) {
-    /* We might potentially see another RECV_MESSAGE op. In that case, we do not
-     * want to run the recv_trailing_metadata_ready closure again. The newer
-     * RECV_MESSAGE op cannot cause any errors since the transport has already
-     * invoked the recv_trailing_metadata_ready closure and all further
-     * RECV_MESSAGE ops will get null payloads. */
+    // We might potentially see another RECV_MESSAGE op. In that case, we do not
+    // want to run the recv_trailing_metadata_ready closure again. The newer
+    // RECV_MESSAGE op cannot cause any errors since the transport has already
+    // invoked the recv_trailing_metadata_ready closure and all further
+    // RECV_MESSAGE ops will get null payloads.
     calld->seen_recv_trailing_metadata = false;
     GRPC_CALL_COMBINER_START(calld->call_combiner,
                              &calld->recv_trailing_metadata_ready,

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

@@ -87,4 +87,4 @@ absl::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_MESSAGE_SIZE_MESSAGE_SIZE_FILTER_H */
+#endif  // GRPC_CORE_EXT_FILTERS_MESSAGE_SIZE_MESSAGE_SIZE_FILTER_H

data/src/core/ext/filters/server_config_selector/server_config_selector.h

@@ -24,13 +24,10 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -43,14 +40,15 @@ class ServerConfigSelector : public RefCounted<ServerConfigSelector> {
  public:
   // Configuration to apply to an incoming call
   struct CallConfig {
-    grpc_error_handle error;
     const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
     RefCountedPtr<ServiceConfig> service_config;
   };
 
   ~ServerConfigSelector() override = default;
+
   // Returns the CallConfig to apply to a call based on the incoming \a metadata
-  virtual CallConfig GetCallConfig(grpc_metadata_batch* metadata) = 0;
+  virtual absl::StatusOr<CallConfig> GetCallConfig(
+      grpc_metadata_batch* metadata) = 0;
 };
 
 // ServerConfigSelectorProvider allows for subscribers to watch for updates on
@@ -71,13 +69,13 @@ class ServerConfigSelectorProvider
       std::unique_ptr<ServerConfigSelectorWatcher> watcher) = 0;
   virtual void CancelWatch() = 0;
 
-  static absl::string_view ChannelArgName();
+  static absl::string_view ChannelArgName() {
+    return "grpc.internal.server_config_selector_provider";
+  }
   static int ChannelArgsCompare(const ServerConfigSelectorProvider* a,
                                 const ServerConfigSelectorProvider* b) {
     return QsortCompare(a, b);
   }
-
-  grpc_arg MakeChannelArg() const;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/server_config_selector/server_config_selector_filter.cc

@@ -34,7 +34,6 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/promise.h"
@@ -135,15 +134,15 @@ ArenaPromise<ServerMetadataHandle> ServerConfigSelectorFilter::MakeCallPromise(
   if (!sel.ok()) return Immediate(ServerMetadataFromStatus(sel.status()));
   auto call_config =
       sel.value()->GetCallConfig(call_args.client_initial_metadata.get());
-  if (!call_config.error.ok()) {
+  if (!call_config.ok()) {
     auto r = Immediate(ServerMetadataFromStatus(
-        absl::UnavailableError(StatusToString(call_config.error))));
+        absl::UnavailableError(StatusToString(call_config.status()))));
     return std::move(r);
   }
   auto& ctx = GetContext<
       grpc_call_context_element>()[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA];
   ctx.value = GetContext<Arena>()->New<ServiceConfigCallData>(
-      std::move(call_config.service_config), call_config.method_configs,
+      std::move(call_config->service_config), call_config->method_configs,
       ServiceConfigCallData::CallAttributes{});
   ctx.destroy = [](void* p) {
     static_cast<ServiceConfigCallData*>(p)->~ServiceConfigCallData();

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

@@ -0,0 +1,229 @@
+//
+// Copyright 2022 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 <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/stateful_session/stateful_session_filter.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/log.h>
+#include <grpc/support/time.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/channel/context.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/seq.h"
+#include "src/core/lib/promise/try_concurrently.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+TraceFlag grpc_stateful_session_filter_trace(false, "stateful_session_filter");
+
+UniqueTypeName XdsHostOverrideTypeName() {
+  static UniqueTypeName::Factory kFactory("xds_host_override");
+  return kFactory.Create();
+}
+
+const grpc_channel_filter StatefulSessionFilter::kFilter =
+    MakePromiseBasedFilter<StatefulSessionFilter, FilterEndpoint::kClient>(
+        "stateful_session_filter");
+
+absl::StatusOr<StatefulSessionFilter> StatefulSessionFilter::Create(
+    const ChannelArgs&, ChannelFilter::Args filter_args) {
+  return StatefulSessionFilter(filter_args);
+}
+
+StatefulSessionFilter::StatefulSessionFilter(ChannelFilter::Args filter_args)
+    : index_(grpc_channel_stack_filter_instance_number(
+          filter_args.channel_stack(),
+          filter_args.uninitialized_channel_element())),
+      service_config_parser_index_(
+          StatefulSessionServiceConfigParser::ParserIndex()) {}
+
+namespace {
+
+// Adds the set-cookie header to the server initial metadata if needed.
+void MaybeUpdateServerInitialMetadata(
+    const StatefulSessionMethodParsedConfig::CookieConfig* cookie_config,
+    absl::optional<absl::string_view> cookie_value,
+    ServerMetadata* server_initial_metadata) {
+  // Get peer string.
+  auto peer_string = server_initial_metadata->get(PeerString());
+  if (!peer_string.has_value()) return;  // Nothing we can do.
+  // If there was no cookie or if the address changed, set the cookie.
+  if (!cookie_value.has_value() || *peer_string != *cookie_value) {
+    std::vector<std::string> parts = {
+        absl::StrCat(*cookie_config->name, "=",
+                     absl::Base64Escape(*peer_string), "; HttpOnly")};
+    if (!cookie_config->path.empty()) {
+      parts.emplace_back(absl::StrCat("Path=", cookie_config->path));
+    }
+    if (cookie_config->ttl > Duration::Zero()) {
+      parts.emplace_back(
+          absl::StrCat("Max-Age=", cookie_config->ttl.as_timespec().tv_sec));
+    }
+    server_initial_metadata->Append(
+        "set-cookie", Slice::FromCopiedString(absl::StrJoin(parts, "; ")),
+        [](absl::string_view error, const Slice&) {
+          Crash(absl::StrCat("ERROR ADDING set-cookie METADATA: ", error));
+        });
+  }
+}
+
+}  // namespace
+
+// Construct a promise for one call.
+ArenaPromise<ServerMetadataHandle> StatefulSessionFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  // Get config.
+  auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
+      GetContext<
+          grpc_call_context_element>()[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA]
+          .value);
+  GPR_ASSERT(service_config_call_data != nullptr);
+  auto* method_params = static_cast<StatefulSessionMethodParsedConfig*>(
+      service_config_call_data->GetMethodParsedConfig(
+          service_config_parser_index_));
+  GPR_ASSERT(method_params != nullptr);
+  auto* cookie_config = method_params->GetConfig(index_);
+  GPR_ASSERT(cookie_config != nullptr);
+  if (!cookie_config->name.has_value()) {
+    return next_promise_factory(std::move(call_args));
+  }
+  // We have a config.
+  // If the config has a path, check to see if it matches the request path.
+  if (!cookie_config->path.empty()) {
+    Slice* path_slice =
+        call_args.client_initial_metadata->get_pointer(HttpPathMetadata());
+    GPR_ASSERT(path_slice != nullptr);
+    absl::string_view path = path_slice->as_string_view();
+    // Matching criteria from
+    // https://www.rfc-editor.org/rfc/rfc6265#section-5.1.4.
+    if (!absl::StartsWith(path, cookie_config->path) ||
+        (path.size() != cookie_config->path.size() &&
+         cookie_config->path.back() != '/' &&
+         path[cookie_config->path.size() + 1] != '/')) {
+      return next_promise_factory(std::move(call_args));
+    }
+  }
+  // Check to see if we have a host override cookie.
+  auto cookie_value = GetHostOverrideFromCookie(
+      call_args.client_initial_metadata, *cookie_config->name);
+  if (cookie_value.has_value()) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_stateful_session_filter_trace)) {
+      gpr_log(GPR_INFO,
+              "chand=%p: stateful session filter found cookie %s value %s",
+              this, cookie_config->name->c_str(),
+              std::string(*cookie_value).c_str());
+    }
+    // We have a valid cookie, so add the call attribute to be used by the
+    // xds_override_host LB policy.
+    service_config_call_data->SetCallAttribute(XdsHostOverrideTypeName(),
+                                               *cookie_value);
+  }
+  // Intercept server initial metadata.
+  auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
+  auto* write_latch =
+      std::exchange(call_args.server_initial_metadata, read_latch);
+  return TryConcurrently(
+             Seq(next_promise_factory(std::move(call_args)),
+                 [cookie_config, cookie_value](ServerMetadataHandle md) {
+                   // If we got a Trailers-Only response, then add the
+                   // cookie to the trailing metadata instead of the
+                   // initial metadata.
+                   if (md->get(GrpcTrailersOnly()).value_or(false)) {
+                     MaybeUpdateServerInitialMetadata(cookie_config,
+                                                      cookie_value, md.get());
+                   }
+                   return md;
+                 }))
+      .NecessaryPull(Seq(read_latch->Wait(),
+                         [write_latch, cookie_config,
+                          cookie_value](ServerMetadata** md) -> absl::Status {
+                           if (*md != nullptr) {
+                             // Add cookie to server initial metadata if needed.
+                             MaybeUpdateServerInitialMetadata(
+                                 cookie_config, cookie_value, *md);
+                           }
+                           write_latch->Set(*md);
+                           return absl::OkStatus();
+                         }));
+}
+
+absl::optional<absl::string_view>
+StatefulSessionFilter::GetHostOverrideFromCookie(
+    const ClientMetadataHandle& client_initial_metadata,
+    absl::string_view cookie_name) {
+  // Check to see if the cookie header is present.
+  std::string buffer;
+  auto header_value =
+      client_initial_metadata->GetStringValue("cookie", &buffer);
+  if (!header_value.has_value()) return absl::nullopt;
+  // Parse cookie header.
+  std::vector<absl::string_view> values;
+  for (absl::string_view cookie : absl::StrSplit(*header_value, "; ")) {
+    std::pair<absl::string_view, absl::string_view> kv =
+        absl::StrSplit(cookie, absl::MaxSplits('=', 1));
+    if (kv.first == cookie_name) values.push_back(kv.second);
+  }
+  if (values.empty()) return absl::nullopt;
+  // TODO(roth): Figure out the right behavior for multiple cookies.
+  // For now, just choose the first value.
+  absl::string_view value = values.front();
+  // Base64-decode it.
+  std::string decoded_value;
+  if (!absl::Base64Unescape(value, &decoded_value)) return absl::nullopt;
+  // Copy it into the arena, since it will need to persist until the LB pick.
+  char* arena_value =
+      static_cast<char*>(GetContext<Arena>()->Alloc(decoded_value.size()));
+  memcpy(arena_value, decoded_value.c_str(), decoded_value.size());
+  return absl::string_view(arena_value, decoded_value.size());
+}
+
+void StatefulSessionFilterRegister(CoreConfiguration::Builder* builder) {
+  StatefulSessionServiceConfigParser::Register(builder);
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,66 @@
+//
+// Copyright 2022 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.
+//
+
+#ifndef GRPC_CORE_EXT_FILTERS_STATEFUL_SESSION_STATEFUL_SESSION_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_STATEFUL_SESSION_STATEFUL_SESSION_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.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/gprpp/unique_type_name.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+UniqueTypeName XdsHostOverrideTypeName();
+
+// A filter to provide cookie-based stateful session affinity.
+class StatefulSessionFilter : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<StatefulSessionFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  explicit StatefulSessionFilter(ChannelFilter::Args filter_args);
+
+  absl::optional<absl::string_view> GetHostOverrideFromCookie(
+      const ClientMetadataHandle& initial_metadata,
+      absl::string_view cookie_name);
+
+  // 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_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_STATEFUL_SESSION_STATEFUL_SESSION_FILTER_H