Allow http route and cluster metadata to contain typed metadata in An…

api/envoy/config/core/v3/base.proto

@@ -236,7 +236,19 @@ message Metadata {
 
   // Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.*
   // namespace is reserved for Envoy's built-in filters.
+  // If both *filter_metadata* and
+  // :ref:`typed_filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.typed_filter_metadata>`
+  // fields are present in the metadata with same keys,
+  // only *typed_filter_metadata* field will be parsed.
   map<string, google.protobuf.Struct> filter_metadata = 1;
+
+  // Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.*
+  // namespace is reserved for Envoy's built-in filters.
+  // The value is encoded as google.protobuf.Any.
+  // If both :ref:`filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.filter_metadata>`
+  // and *typed_filter_metadata* fields are present in the metadata with same keys,
+  // only *typed_filter_metadata* field will be parsed.
+  map<string, google.protobuf.Any> typed_filter_metadata = 2;
 }
 
 // Runtime derived uint32 with a default when not specified.

include/envoy/config/typed_metadata.h

@@ -65,6 +65,17 @@ class TypedMetadataFactory : public UntypedFactory {
   virtual std::unique_ptr<const TypedMetadata::Object>
   parse(const ProtobufWkt::Struct& data) const PURE;
 
+  /**
+   * Convert the google.protobuf.Any into an instance of TypedMetadata::Object.
+   * It should throw an EnvoyException in case the conversion can't be completed.
+   * @param data config data stored as a protobuf any.
+   * @return a derived class object pointer of TypedMetadata or return nullptr if
+   * one doesn't implement parse() method.
+   * @throw EnvoyException if the parsing can't be done.
+   */
+  virtual std::unique_ptr<const TypedMetadata::Object>
+  parse(const ProtobufWkt::Any& data) const PURE;
+
   std::string category() const override { return "envoy.typed_metadata"; }
 };
 

source/common/config/metadata.h

@@ -116,8 +116,20 @@ template <typename factoryClass> class TypedMetadataImpl : public TypedMetadata
    */
   void populateFrom(const envoy::config::core::v3::Metadata& metadata) {
     auto& data_by_key = metadata.filter_metadata();
+    auto& typed_data_by_key = metadata.typed_filter_metadata();
     for (const auto& [factory_name, factory] :
          Registry::FactoryRegistry<factoryClass>::factories()) {
+      const auto& typed_meta_iter = typed_data_by_key.find(factory_name);
+      // If the key exists in Any metadata, and parse() does not return nullptr,
+      // populate data_.
+      if (typed_meta_iter != typed_data_by_key.end()) {
+        auto result = factory->parse(typed_meta_iter->second);
+        if (result != nullptr) {
+          data_[factory->name()] = std::move(result);
+          continue;
+        }
+      }
+      // Fall back cases to parsing Struct metadata and populate data_.
       const auto& meta_iter = data_by_key.find(factory_name);
       if (meta_iter != data_by_key.end()) {
         data_[factory->name()] = factory->parse(meta_iter->second);

test/common/config/metadata_test.cc

@@ -51,76 +51,230 @@ TEST(MetadataTest, MetadataValuePath) {
 
 class TypedMetadataTest : public testing::Test {
 public:
-  TypedMetadataTest() : registered_factory_(foo_factory_) {}
+  TypedMetadataTest()
+      : registered_factory_foo_(foo_factory_), registered_factory_bar_(bar_factory_),
+        registered_factory_baz_(baz_factory_) {}
 
   struct Foo : public TypedMetadata::Object {
     Foo(std::string name) : name_(name) {}
     std::string name_;
   };
 
-  struct Bar : public TypedMetadata::Object {};
+  struct Qux : public TypedMetadata::Object {};
 
-  class FooFactory : public TypedMetadataFactory {
+  class FoobarFactory : public TypedMetadataFactory {
   public:
-    std::string name() const override { return "foo"; }
     // Throws EnvoyException (conversion failure) if d is empty.
     std::unique_ptr<const TypedMetadata::Object>
     parse(const ProtobufWkt::Struct& d) const override {
       if (d.fields().find("name") != d.fields().end()) {
         return std::make_unique<Foo>(d.fields().at("name").string_value());
       }
-      throw EnvoyException("Cannot create a Foo when metadata is empty.");
+      throw EnvoyException("Cannot create a Foo when Struct metadata is empty.");
+    }
+
+    std::unique_ptr<const TypedMetadata::Object> parse(const ProtobufWkt::Any& d) const override {
+      if (!(d.type_url().empty())) {
+        return std::make_unique<Foo>(d.value());
+      }
+      throw EnvoyException("Cannot create a Foo when Any metadata is empty.");
+    }
+  };
+
+  // Three testing factories with different names
+  class FooFactory : public FoobarFactory {
+  public:
+    std::string name() const override { return "foo"; }
+  };
+
+  class BarFactory : public FoobarFactory {
+  public:
+    std::string name() const override { return "bar"; }
+  };
+
+  class BazFactory : public FoobarFactory {
+  public:
+    std::string name() const override { return "baz"; }
+    using FoobarFactory::parse;
+    // Override Any parse() to just return nullptr.
+    std::unique_ptr<const TypedMetadata::Object> parse(const ProtobufWkt::Any&) const override {
+      return nullptr;
     }
   };
 
 protected:
   FooFactory foo_factory_;
-  Registry::InjectFactory<TypedMetadataFactory> registered_factory_;
+  BarFactory bar_factory_;
+  BazFactory baz_factory_;
+  Registry::InjectFactory<TypedMetadataFactory> registered_factory_foo_;
+  Registry::InjectFactory<TypedMetadataFactory> registered_factory_bar_;
+  Registry::InjectFactory<TypedMetadataFactory> registered_factory_baz_;
 };
 
-TEST_F(TypedMetadataTest, OkTest) {
+// Tests data parsing and retrieving when only Struct field present in the metadata.
+TEST_F(TypedMetadataTest, OkTestStruct) {
   envoy::config::core::v3::Metadata metadata;
   (*metadata.mutable_filter_metadata())[foo_factory_.name()] =
-      MessageUtil::keyValueStruct("name", "foo");
+      MessageUtil::keyValueStruct("name", "garply");
   TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
   EXPECT_NE(nullptr, typed.get<Foo>(foo_factory_.name()));
-  EXPECT_EQ("foo", typed.get<Foo>(foo_factory_.name())->name_);
+  EXPECT_EQ("garply", typed.get<Foo>(foo_factory_.name())->name_);
   // A duck is a duck.
-  EXPECT_EQ(nullptr, typed.get<Bar>(foo_factory_.name()));
+  EXPECT_EQ(nullptr, typed.get<Qux>(foo_factory_.name()));
+}
+
+// Tests data parsing and retrieving when only Any field present in the metadata.
+TEST_F(TypedMetadataTest, OkTestAny) {
+  envoy::config::core::v3::Metadata metadata;
+  ProtobufWkt::Any any;
+  any.set_type_url("type.googleapis.com/waldo");
+  any.set_value("fred");
+  (*metadata.mutable_typed_filter_metadata())[bar_factory_.name()] = any;
+  TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
+  EXPECT_NE(nullptr, typed.get<Foo>(bar_factory_.name()));
+  EXPECT_EQ("fred", typed.get<Foo>(bar_factory_.name())->name_);
+}
+
+// Tests data parsing and retrieving when only Any field present in the metadata,
+// also Any data parsing method just return nullptr.
+TEST_F(TypedMetadataTest, OkTestAnyParseReturnNullptr) {
+  envoy::config::core::v3::Metadata metadata;
+  ProtobufWkt::Any any;
+  any.set_type_url("type.googleapis.com/waldo");
+  any.set_value("fred");
+  (*metadata.mutable_typed_filter_metadata())[baz_factory_.name()] = any;
+  TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
+  EXPECT_EQ(nullptr, typed.get<Foo>(baz_factory_.name()));
+}
+
+// Tests data parsing and retrieving when both Struct and Any field
+// present in the metadata, and in the same factory.
+TEST_F(TypedMetadataTest, OkTestBothSameFactory) {
+  envoy::config::core::v3::Metadata metadata;
+  (*metadata.mutable_filter_metadata())[foo_factory_.name()] =
+      MessageUtil::keyValueStruct("name", "garply");
+  ProtobufWkt::Any any;
+  any.set_type_url("type.googleapis.com/waldo");
+  any.set_value("fred");
+  (*metadata.mutable_typed_filter_metadata())[foo_factory_.name()] = any;
+  TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
+  EXPECT_NE(nullptr, typed.get<Foo>(foo_factory_.name()));
+  // If metadata has both Struct and Any field in same factory,
+  // only Any field is populated.
+  EXPECT_EQ("fred", typed.get<Foo>(foo_factory_.name())->name_);
+}
+
+// Tests data parsing and retrieving when both Struct and Any field
+// present in the metadata, but in different factory.
+TEST_F(TypedMetadataTest, OkTestBothDifferentFactory) {
+  envoy::config::core::v3::Metadata metadata;
+  (*metadata.mutable_filter_metadata())[foo_factory_.name()] =
+      MessageUtil::keyValueStruct("name", "garply");
+  ProtobufWkt::Any any;
+  any.set_type_url("type.googleapis.com/waldo");
+  any.set_value("fred");
+  (*metadata.mutable_typed_filter_metadata())[bar_factory_.name()] = any;
+
+  TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
+  // If metadata has both Struct and Any field in different factory,
+  // both fields are populated.
+  EXPECT_NE(nullptr, typed.get<Foo>(foo_factory_.name()));
+  EXPECT_EQ("garply", typed.get<Foo>(foo_factory_.name())->name_);
+
+  EXPECT_NE(nullptr, typed.get<Foo>(bar_factory_.name()));
+  EXPECT_EQ("fred", typed.get<Foo>(bar_factory_.name())->name_);
+}
+
+// Tests data parsing and retrieving when both Struct and Any field
+// present in the metadata, and in the same factory, but with the case
+// that Any field parse() method returns nullptr.
+TEST_F(TypedMetadataTest, OkTestBothSameFactoryAnyParseReturnNullptr) {
+  envoy::config::core::v3::Metadata metadata;
+  (*metadata.mutable_filter_metadata())[baz_factory_.name()] =
+      MessageUtil::keyValueStruct("name", "garply");
+  ProtobufWkt::Any any;
+  any.set_type_url("type.googleapis.com/waldo");
+  any.set_value("fred");
+  (*metadata.mutable_typed_filter_metadata())[baz_factory_.name()] = any;
+
+  // Since Any Parse() method in BazFactory just return nullptr,
+  // Struct data is populated.
+  TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
+  EXPECT_NE(nullptr, typed.get<Foo>(baz_factory_.name()));
+  EXPECT_EQ("garply", typed.get<Foo>(baz_factory_.name())->name_);
 }
 
+// Tests data parsing and retrieving when no data present in the metadata.
 TEST_F(TypedMetadataTest, NoMetadataTest) {
   envoy::config::core::v3::Metadata metadata;
   TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
+  // metadata is empty, nothing is populated.
   EXPECT_EQ(nullptr, typed.get<Foo>(foo_factory_.name()));
 }
 
-TEST_F(TypedMetadataTest, MetadataRefreshTest) {
+// Tests data parsing and retrieving when Struct metadata updates.
+TEST_F(TypedMetadataTest, StructMetadataRefreshTest) {
   envoy::config::core::v3::Metadata metadata;
   (*metadata.mutable_filter_metadata())[foo_factory_.name()] =
-      MessageUtil::keyValueStruct("name", "foo");
+      MessageUtil::keyValueStruct("name", "garply");
   TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
   EXPECT_NE(nullptr, typed.get<Foo>(foo_factory_.name()));
-  EXPECT_EQ("foo", typed.get<Foo>(foo_factory_.name())->name_);
+  EXPECT_EQ("garply", typed.get<Foo>(foo_factory_.name())->name_);
 
   // Updated.
   (*metadata.mutable_filter_metadata())[foo_factory_.name()] =
-      MessageUtil::keyValueStruct("name", "bar");
+      MessageUtil::keyValueStruct("name", "plugh");
   TypedMetadataImpl<TypedMetadataFactory> typed2(metadata);
   EXPECT_NE(nullptr, typed2.get<Foo>(foo_factory_.name()));
-  EXPECT_EQ("bar", typed2.get<Foo>(foo_factory_.name())->name_);
+  EXPECT_EQ("plugh", typed2.get<Foo>(foo_factory_.name())->name_);
 
   // Deleted.
   (*metadata.mutable_filter_metadata()).erase(foo_factory_.name());
   TypedMetadataImpl<TypedMetadataFactory> typed3(metadata);
   EXPECT_EQ(nullptr, typed3.get<Foo>(foo_factory_.name()));
 }
 
-TEST_F(TypedMetadataTest, InvalidMetadataTest) {
+// Tests data parsing and retrieving when Any metadata updates.
+TEST_F(TypedMetadataTest, AnyMetadataRefreshTest) {
+  envoy::config::core::v3::Metadata metadata;
+  ProtobufWkt::Any any;
+  any.set_type_url("type.googleapis.com/waldo");
+  any.set_value("fred");
+  (*metadata.mutable_typed_filter_metadata())[bar_factory_.name()] = any;
+  TypedMetadataImpl<TypedMetadataFactory> typed(metadata);
+  EXPECT_NE(nullptr, typed.get<Foo>(bar_factory_.name()));
+  EXPECT_EQ("fred", typed.get<Foo>(bar_factory_.name())->name_);
+
+  // Updated.
+  any.set_type_url("type.googleapis.com/xyzzy");
+  any.set_value("thud");
+  (*metadata.mutable_typed_filter_metadata())[bar_factory_.name()] = any;
+  TypedMetadataImpl<TypedMetadataFactory> typed2(metadata);
+  EXPECT_NE(nullptr, typed2.get<Foo>(bar_factory_.name()));
+  EXPECT_EQ("thud", typed2.get<Foo>(bar_factory_.name())->name_);
+
+  // Deleted.
+  (*metadata.mutable_typed_filter_metadata()).erase(bar_factory_.name());
+  TypedMetadataImpl<TypedMetadataFactory> typed3(metadata);
+  EXPECT_EQ(nullptr, typed3.get<Foo>(bar_factory_.name()));
+}
+
+// Tests empty Struct metadata parsing case.
+TEST_F(TypedMetadataTest, InvalidStructMetadataTest) {
   envoy::config::core::v3::Metadata metadata;
   (*metadata.mutable_filter_metadata())[foo_factory_.name()] = ProtobufWkt::Struct();
   EXPECT_THROW_WITH_MESSAGE(TypedMetadataImpl<TypedMetadataFactory> typed(metadata),
-                            Envoy::EnvoyException, "Cannot create a Foo when metadata is empty.");
+                            Envoy::EnvoyException,
+                            "Cannot create a Foo when Struct metadata is empty.");
+}
+
+// Tests empty Any metadata parsing case.
+TEST_F(TypedMetadataTest, InvalidAnyMetadataTest) {
+  envoy::config::core::v3::Metadata metadata;
+  (*metadata.mutable_typed_filter_metadata())[bar_factory_.name()] = ProtobufWkt::Any();
+  EXPECT_THROW_WITH_MESSAGE(TypedMetadataImpl<TypedMetadataFactory> typed(metadata),
+                            Envoy::EnvoyException,
+                            "Cannot create a Foo when Any metadata is empty.");
 }
 
 } // namespace

test/common/router/config_impl_test.cc

@@ -5020,6 +5020,11 @@ class BazFactory : public HttpRouteTypedMetadataFactory {
     }
     throw EnvoyException("Cannot create a Baz when metadata is empty.");
   }
+
+  std::unique_ptr<const Envoy::Config::TypedMetadata::Object>
+  parse(const ProtobufWkt::Any&) const override {
+    return nullptr;
+  }
 };
 
 TEST_F(RouteMatcherTest, WeightedClusters) {

test/common/upstream/upstream_impl_test.cc

@@ -2255,6 +2255,11 @@ class BazFactory : public ClusterTypedMetadataFactory {
     }
     throw EnvoyException("Cannot create a Baz when metadata is empty.");
   }
+
+  std::unique_ptr<const Envoy::Config::TypedMetadata::Object>
+  parse(const ProtobufWkt::Any&) const override {
+    return nullptr;
+  }
 };
 
 // Cluster metadata and common config retrieval.