stream_info: Add the concept of "life span" to StreamInfo::FilterState

include/envoy/stream_info/filter_state.h

@@ -22,6 +22,11 @@ namespace StreamInfo {
 class FilterState {
 public:
   enum class StateType { ReadOnly, Mutable };
+  // When internal redirect is enabled, one downstream request may create multiple filter chains.
+  // DownstreamRequest allows an object to survived across filter chain for book keeping.
+  // Note that order matters in this enum because it's assumed that life span grows as enum number
+  // grows.
+  enum class LifeSpan { FilterChain, DownstreamRequest };
 
   class Object {
   public:
@@ -41,6 +46,8 @@ class FilterState {
    * @param data_name the name of the data being set.
    * @param data an owning pointer to the data to be stored.
    * @param state_type indicates whether the object is mutable or not.
+   * @param life_span indicates the life span of the object: bound to the filter chain or a
+   * downstream request.
    *
    * Note that it is an error to call setData() twice with the same
    * data_name, if the existing object is immutable. Similarly, it is an
@@ -49,8 +56,21 @@ class FilterState {
    * single authoritative source for each piece of immutable data stored in
    * FilterState.
    */
-  virtual void setData(absl::string_view data_name, std::unique_ptr<Object>&& data,
-                       StateType state_type) PURE;
+  virtual void setData(absl::string_view data_name, std::shared_ptr<Object> data,
+                       StateType state_type, LifeSpan life_span = LifeSpan::FilterChain) PURE;
+
+  /**
+   * @param other the FilterState we want to copy current data into.
+   * @param life_span the object life span above or equal to which will be copied.
+   *
+   * This is useful for sharing filter state within bigger life span than a filter chain. For
+   * example, we are going to use it to share router filter state across filter chains created on
+   * the same downstream request for internal redirect handling.
+   *
+   * This can be extended to support connection level sharing fairly easily, but there is not a need
+   * yet.
+   */
+  virtual void copyInto(FilterState& other, LifeSpan life_span) PURE;
 
   /**
    * @param data_name the name of the data being looked up (mutable/readonly).

source/common/http/conn_manager_impl.cc

@@ -14,6 +14,7 @@
 #include "envoy/router/router.h"
 #include "envoy/ssl/connection.h"
 #include "envoy/stats/scope.h"
+#include "envoy/stream_info/filter_state.h"
 #include "envoy/tracing/http_tracer.h"
 
 #include "common/buffer/buffer_impl.h"
@@ -2220,6 +2221,10 @@ bool ConnectionManagerImpl::ActiveStreamDecoderFilter::recreateStream() {
   parent_.connection_manager_.doEndStream(this->parent_);
 
   StreamDecoder& new_stream = parent_.connection_manager_.newStream(*response_encoder, true);
+  parent_.stream_info_.filterState().copyInto(
+      (*parent_.connection_manager_.streams_.begin())->stream_info_.filterState(),
+      StreamInfo::FilterState::LifeSpan::DownstreamRequest);
+
   new_stream.decodeHeaders(std::move(request_headers), true);
   return true;
 }

source/common/stream_info/filter_state_impl.cc

@@ -5,8 +5,8 @@
 namespace Envoy {
 namespace StreamInfo {
 
-void FilterStateImpl::setData(absl::string_view data_name, std::unique_ptr<Object>&& data,
-                              FilterState::StateType state_type) {
+void FilterStateImpl::setData(absl::string_view data_name, std::shared_ptr<Object> data,
+                              FilterState::StateType state_type, FilterState::LifeSpan life_span) {
   const auto& it = data_storage_.find(data_name);
   if (it != data_storage_.end()) {
     // We have another object with same data_name. Check for mutability
@@ -25,9 +25,19 @@ void FilterStateImpl::setData(absl::string_view data_name, std::unique_ptr<Objec
   std::unique_ptr<FilterStateImpl::FilterObject> filter_object(new FilterStateImpl::FilterObject());
   filter_object->data_ = std::move(data);
   filter_object->state_type_ = state_type;
+  filter_object->life_span_ = life_span;
   data_storage_[data_name] = std::move(filter_object);
 }
 
+void FilterStateImpl::copyInto(FilterState& other, LifeSpan life_span) {
+  for (const auto& filter_object : data_storage_) {
+    if (filter_object.second->life_span_ >= life_span) {
+      other.setData(filter_object.first, filter_object.second->data_,
+                    filter_object.second->state_type_, filter_object.second->life_span_);
+    }
+  }
+}
+
 bool FilterStateImpl::hasDataWithName(absl::string_view data_name) const {
   return data_storage_.count(data_name) > 0;
 }

source/common/stream_info/filter_state_impl.h

@@ -14,16 +14,19 @@ namespace StreamInfo {
 class FilterStateImpl : public FilterState {
 public:
   // FilterState
-  void setData(absl::string_view data_name, std::unique_ptr<Object>&& data,
-               FilterState::StateType state_type) override;
+  void setData(absl::string_view data_name, std::shared_ptr<Object> data,
+               FilterState::StateType state_type,
+               FilterState::LifeSpan life_span = FilterState::LifeSpan::FilterChain) override;
+  void copyInto(FilterState& other, FilterState::LifeSpan life_span) override;
   bool hasDataWithName(absl::string_view) const override;
   const Object* getDataReadOnlyGeneric(absl::string_view data_name) const override;
   Object* getDataMutableGeneric(absl::string_view data_name) override;
 
 private:
   struct FilterObject {
-    std::unique_ptr<Object> data_;
+    std::shared_ptr<Object> data_;
     FilterState::StateType state_type_;
+    FilterState::LifeSpan life_span_;
   };
 
   absl::flat_hash_map<std::string, std::unique_ptr<FilterObject>> data_storage_;

test/common/stream_info/filter_state_impl_test.cc

@@ -239,5 +239,45 @@ TEST_F(FilterStateImplTest, HasData) {
   EXPECT_FALSE(filter_state().hasDataWithName("test_2"));
 }
 
+TEST_F(FilterStateImplTest, LifeSpan) {
+  filter_state().setData("test_1", std::make_unique<SimpleType>(1),
+                         FilterState::StateType::ReadOnly);
+  filter_state().setData("test_2", std::make_unique<SimpleType>(2),
+                         FilterState::StateType::Mutable);
+  filter_state().setData("test_3", std::make_unique<SimpleType>(3),
+                         FilterState::StateType::ReadOnly,
+                         FilterState::LifeSpan::DownstreamRequest);
+  filter_state().setData("test_4", std::make_unique<SimpleType>(4), FilterState::StateType::Mutable,
+                         FilterState::LifeSpan::DownstreamRequest);
+  {
+    FilterStateImpl new_filter_state;
+    filter_state().copyInto(new_filter_state, FilterState::LifeSpan::DownstreamRequest);
+    EXPECT_FALSE(new_filter_state.hasDataWithName("test_1"));
+    EXPECT_FALSE(new_filter_state.hasDataWithName("test_2"));
+    EXPECT_TRUE(new_filter_state.hasDataWithName("test_3"));
+    EXPECT_TRUE(new_filter_state.hasDataWithName("test_4"));
+    EXPECT_THROW_WITH_MESSAGE(
+        new_filter_state.getDataMutable<SimpleType>("test_3"), EnvoyException,
+        "FilterState::getDataMutable<T> tried to access immutable data as mutable.");
+    EXPECT_EQ(4, new_filter_state.getDataMutable<SimpleType>("test_4").access());
+  }
+  {
+    FilterStateImpl new_filter_state;
+    filter_state().copyInto(new_filter_state, FilterState::LifeSpan::FilterChain);
+    EXPECT_TRUE(new_filter_state.hasDataWithName("test_1"));
+    EXPECT_TRUE(new_filter_state.hasDataWithName("test_2"));
+    EXPECT_TRUE(new_filter_state.hasDataWithName("test_3"));
+    EXPECT_TRUE(new_filter_state.hasDataWithName("test_4"));
+    EXPECT_THROW_WITH_MESSAGE(
+        new_filter_state.getDataMutable<SimpleType>("test_1"), EnvoyException,
+        "FilterState::getDataMutable<T> tried to access immutable data as mutable.");
+    EXPECT_EQ(2, new_filter_state.getDataMutable<SimpleType>("test_2").access());
+    EXPECT_THROW_WITH_MESSAGE(
+        new_filter_state.getDataMutable<SimpleType>("test_3"), EnvoyException,
+        "FilterState::getDataMutable<T> tried to access immutable data as mutable.");
+    EXPECT_EQ(4, new_filter_state.getDataMutable<SimpleType>("test_4").access());
+  }
+}
+
 } // namespace StreamInfo
 } // namespace Envoy