formatter: support for virtual host metadata

api/envoy/extensions/formatter/metadata/v3/metadata.proto

@@ -22,6 +22,7 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 // * ROUTE
 // * UPSTREAM_HOST
 // * LISTENER
+// * VIRTUAL_HOST
 //
 // See :ref:`here <config_access_log>` for more information on access log configuration.
 

changelogs/current.yaml

@@ -434,6 +434,9 @@ new_features:
     Added :ref:`strip_failure_response
     <envoy_v3_api_field_extensions.filters.http.jwt_authn.v3.JwtAuthentication.strip_failure_response>`
     to allow stripping the failure response details from the JWT authentication filter.
+- area: formatter
+  change: |
+    added formatters for :ref:`METADATA(VIRTUAL_HOST)<envoy_v3_api_msg_extensions.formatter.metadata.v3.Metadata>`.
 - area: quic
   change: |
     Added :ref:`DataSourceServerPreferredAddressConfig

source/extensions/formatter/metadata/metadata.cc

@@ -46,6 +46,29 @@ class ListenerMetadataFormatter : public ::Envoy::Formatter::MetadataFormatter {
             }) {}
 };
 
+// Metadata formatter for virtual host metadata.
+class VirtualHostMetadataFormatter : public ::Envoy::Formatter::MetadataFormatter {
+public:
+  VirtualHostMetadataFormatter(const std::string& filter_namespace,
+                               const std::vector<std::string>& path,
+                               absl::optional<size_t> max_length)
+      : ::Envoy::Formatter::MetadataFormatter(filter_namespace, path, max_length,
+                                              [](const StreamInfo::StreamInfo& stream_info)
+                                                  -> const envoy::config::core::v3::Metadata* {
+                                                Router::RouteConstSharedPtr route =
+                                                    stream_info.route();
+                                                if (route == nullptr) {
+                                                  return nullptr;
+                                                }
+                                                const Router::RouteEntry* route_entry =
+                                                    route->routeEntry();
+                                                if (route_entry == nullptr) {
+                                                  return nullptr;
+                                                }
+                                                return &route_entry->virtualHost().metadata();
+                                              }) {}
+};
+
 // Constructor registers all types of supported metadata along with the
 // handlers accessing the required metadata type.
 MetadataFormatterCommandParser::MetadataFormatterCommandParser() {
@@ -78,6 +101,12 @@ MetadataFormatterCommandParser::MetadataFormatterCommandParser() {
                                                  absl::optional<size_t> max_length) {
     return std::make_unique<ListenerMetadataFormatter>(filter_namespace, path, max_length);
   };
+
+  metadata_formatter_providers_["VIRTUAL_HOST"] = [](const std::string& filter_namespace,
+                                                     const std::vector<std::string>& path,
+                                                     absl::optional<size_t> max_length) {
+    return std::make_unique<VirtualHostMetadataFormatter>(filter_namespace, path, max_length);
+  };
 }
 
 ::Envoy::Formatter::FormatterProviderPtr

test/extensions/formatter/metadata/metadata_test.cc

@@ -146,6 +146,36 @@ TEST_F(MetadataFormatterTest, NoListenerMetadata) {
       getTestMetadataFormatter("LISTENER")->formatWithContext(formatter_context_, stream_info_));
 }
 
+// Test that METADATA(VIRTUAL_HOST accesses selected virtual host metadata.
+TEST_F(MetadataFormatterTest, VirtualHostMetadata) {
+  std::shared_ptr<Router::MockRoute> route{new NiceMock<Router::MockRoute>()};
+  EXPECT_CALL(stream_info_, route()).WillRepeatedly(testing::Return(route));
+
+  std::shared_ptr<Router::MockRouteEntry> route_entry{new NiceMock<Router::MockRouteEntry>()};
+  EXPECT_CALL(*route, routeEntry()).WillRepeatedly(testing::Return(route_entry.get()));
+
+  std::shared_ptr<Router::MockVirtualHost> virtual_host{new NiceMock<Router::MockVirtualHost>()};
+  EXPECT_CALL(*route_entry, virtualHost()).WillRepeatedly(testing::ReturnRef(*virtual_host));
+
+  EXPECT_CALL(*virtual_host, metadata()).WillRepeatedly(testing::ReturnRef(*metadata_));
+  EXPECT_EQ("test_value", getTestMetadataFormatter("VIRTUAL_HOST")
+                              ->formatWithContext(formatter_context_, stream_info_));
+}
+
+TEST_F(MetadataFormatterTest, VirtualHostMetadataNoRoute) {
+  EXPECT_CALL(stream_info_, route()).WillRepeatedly(testing::Return(nullptr));
+  EXPECT_EQ("-", getTestMetadataFormatter("VIRTUAL_HOST")
+                     ->formatWithContext(formatter_context_, stream_info_));
+}
+
+TEST_F(MetadataFormatterTest, VirtualHostMetadataNoRouteEntry) {
+  std::shared_ptr<Router::MockRoute> route{new NiceMock<Router::MockRoute>()};
+  EXPECT_CALL(stream_info_, route()).WillRepeatedly(testing::Return(route));
+  EXPECT_CALL(*route, routeEntry()).WillRepeatedly(testing::Return(nullptr));
+  EXPECT_EQ("-", getTestMetadataFormatter("VIRTUAL_HOST")
+                     ->formatWithContext(formatter_context_, stream_info_));
+}
+
 } // namespace Formatter
 } // namespace Extensions
 } // namespace Envoy