Listener ECDS: Adding config provider manager implemantion for listener filter

envoy/filter/config_provider_manager.h

@@ -23,7 +23,7 @@ using DynamicFilterConfigProviderPtr = std::unique_ptr<DynamicFilterConfigProvid
  * The FilterConfigProviderManager exposes the ability to get an FilterConfigProvider
  * for both static and dynamic filter config providers.
  */
-template <class FactoryCb> class FilterConfigProviderManager {
+template <class FactoryCb, class FactoryCt> class FilterConfigProviderManager {
 public:
   virtual ~FilterConfigProviderManager() = default;
 
@@ -40,7 +40,7 @@ template <class FactoryCb> class FilterConfigProviderManager {
    */
   virtual DynamicFilterConfigProviderPtr<FactoryCb> createDynamicFilterConfigProvider(
       const envoy::config::core::v3::ExtensionConfigSource& config_source,
-      const std::string& filter_config_name, Server::Configuration::FactoryContext& factory_context,
+      const std::string& filter_config_name, FactoryCt& factory_context,
       const std::string& stat_prefix, bool last_filter_in_filter_chain,
       const std::string& filter_chain_type) PURE;
 

source/common/filter/config_discovery_impl.cc

@@ -17,6 +17,7 @@ namespace Envoy {
 namespace Filter {
 
 constexpr absl::string_view HttpStatPrefix = "http_filter.";
+constexpr absl::string_view ListenerStatPrefix = "listener_filter.";
 
 namespace {
 void validateTypeUrlHelper(const std::string& type_url,
@@ -232,18 +233,6 @@ void FilterConfigProviderManagerImplBase::applyLastOrDefaultConfig(
   }
 }
 
-std::tuple<ProtobufTypes::MessagePtr, std::string> HttpFilterConfigProviderManagerImpl::getMessage(
-    const envoy::config::core::v3::TypedExtensionConfig& filter_config,
-    Server::Configuration::ServerFactoryContext& factory_context) const {
-  auto& factory =
-      Config::Utility::getAndCheckFactory<Server::Configuration::NamedHttpFilterConfigFactory>(
-          filter_config);
-  ProtobufTypes::MessagePtr message = Config::Utility::translateAnyToFactoryConfig(
-      filter_config.typed_config(),
-      factory_context.messageValidationContext().dynamicValidationVisitor(), factory);
-  return {std::move(message), factory.name()};
-}
-
 absl::string_view HttpFilterConfigProviderManagerImpl::statPrefix() const { return HttpStatPrefix; }
 
 ProtobufTypes::MessagePtr HttpFilterConfigProviderManagerImpl::getDefaultConfig(
@@ -269,5 +258,28 @@ ProtobufTypes::MessagePtr HttpFilterConfigProviderManagerImpl::getDefaultConfig(
   return message;
 }
 
+absl::string_view ListenerFilterConfigProviderManagerImpl::statPrefix() const {
+  return ListenerStatPrefix;
+}
+
+ProtobufTypes::MessagePtr ListenerFilterConfigProviderManagerImpl::getDefaultConfig(
+    const ProtobufWkt::Any& proto_config, const std::string& filter_config_name,
+    Server::Configuration::FactoryContext& factory_context, bool, const std::string&,
+    const absl::flat_hash_set<std::string>& require_type_urls) const {
+  auto* default_factory =
+      Config::Utility::getFactoryByType<Server::Configuration::NamedListenerFilterConfigFactory>(
+          proto_config);
+  if (default_factory == nullptr) {
+    throw EnvoyException(
+        fmt::format("Error: cannot find listener filter factory {} for default filter "
+                    "configuration with type URL {}.",
+                    filter_config_name, proto_config.type_url()));
+  }
+  validateTypeUrlHelper(Config::Utility::getFactoryType(proto_config), require_type_urls);
+  ProtobufTypes::MessagePtr message = Config::Utility::translateAnyToFactoryConfig(
+      proto_config, factory_context.messageValidationVisitor(), *default_factory);
+  return message;
+}
+
 } // namespace Filter
 } // namespace Envoy

source/common/filter/config_discovery_impl.h

@@ -77,8 +77,7 @@ class DynamicFilterConfigProviderImpl : public DynamicFilterConfigProviderImplBa
                                   absl::string_view stat_prefix)
       : DynamicFilterConfigProviderImplBase(subscription, require_type_urls,
                                             last_filter_in_filter_chain, filter_chain_type),
-        stat_prefix_(stat_prefix), factory_context_(factory_context),
-        main_config_(std::make_shared<MainConfig>()),
+        stat_prefix_(stat_prefix), main_config_(std::make_shared<MainConfig>()),
         default_configuration_(std::move(default_config)), tls_(factory_context.threadLocal()) {
     tls_.set([](Event::Dispatcher&) { return std::make_shared<ThreadLocalConfig>(); });
   };
@@ -119,7 +118,6 @@ class DynamicFilterConfigProviderImpl : public DynamicFilterConfigProviderImplBa
 
 protected:
   const std::string& getStatPrefix() const { return stat_prefix_; }
-  Server::Configuration::FactoryContext& getFactoryContext() const { return factory_context_; }
 
 private:
   virtual FactoryCb instantiateFilterFactory(const Protobuf::Message& message) const PURE;
@@ -151,7 +149,6 @@ class DynamicFilterConfigProviderImpl : public DynamicFilterConfigProviderImplBa
   };
 
   const std::string stat_prefix_;
-  Server::Configuration::FactoryContext& factory_context_;
   std::shared_ptr<MainConfig> main_config_;
   const ProtobufTypes::MessagePtr default_configuration_;
   ThreadLocal::TypedSlot<ThreadLocalConfig> tls_;
@@ -161,13 +158,23 @@ class DynamicFilterConfigProviderImpl : public DynamicFilterConfigProviderImplBa
 class HttpDynamicFilterConfigProviderImpl
     : public DynamicFilterConfigProviderImpl<Http::FilterFactoryCb> {
 public:
-  using DynamicFilterConfigProviderImpl::DynamicFilterConfigProviderImpl;
+  HttpDynamicFilterConfigProviderImpl(FilterConfigSubscriptionSharedPtr& subscription,
+                                      const absl::flat_hash_set<std::string>& require_type_urls,
+                                      Server::Configuration::FactoryContext& factory_context,
+                                      ProtobufTypes::MessagePtr&& default_config,
+                                      bool last_filter_in_filter_chain,
+                                      const std::string& filter_chain_type,
+                                      absl::string_view stat_prefix)
+      : DynamicFilterConfigProviderImpl(subscription, require_type_urls, factory_context,
+                                        std::move(default_config), last_filter_in_filter_chain,
+                                        filter_chain_type, stat_prefix),
+        factory_context_(factory_context) {}
   void validateMessage(const std::string& config_name, const Protobuf::Message& message,
                        const std::string& factory_name) const override {
     auto* factory =
         Registry::FactoryRegistry<Server::Configuration::NamedHttpFilterConfigFactory>::getFactory(
             factory_name);
-    const bool is_terminal_filter = factory->isTerminalFilterByProto(message, getFactoryContext());
+    const bool is_terminal_filter = factory->isTerminalFilterByProto(message, factory_context_);
     Config::Utility::validateTerminalFilters(config_name, factory_name, filter_chain_type_,
                                              is_terminal_filter, last_filter_in_filter_chain_);
   }
@@ -176,8 +183,40 @@ class HttpDynamicFilterConfigProviderImpl
   Http::FilterFactoryCb instantiateFilterFactory(const Protobuf::Message& message) const override {
     auto* factory = Registry::FactoryRegistry<Server::Configuration::NamedHttpFilterConfigFactory>::
         getFactoryByType(message.GetTypeName());
-    return factory->createFilterFactoryFromProto(message, getStatPrefix(), getFactoryContext());
+    return factory->createFilterFactoryFromProto(message, getStatPrefix(), factory_context_);
   }
+
+  Server::Configuration::FactoryContext& factory_context_;
+};
+
+// Implementation of a listener dynamic filter config provider.
+class ListenerDynamicFilterConfigProviderImpl
+    : public DynamicFilterConfigProviderImpl<Network::ListenerFilterFactoryCb> {
+public:
+  ListenerDynamicFilterConfigProviderImpl(
+      FilterConfigSubscriptionSharedPtr& subscription,
+      const absl::flat_hash_set<std::string>& require_type_urls,
+      Server::Configuration::ListenerFactoryContext& factory_context,
+      ProtobufTypes::MessagePtr&& default_config, bool last_filter_in_filter_chain,
+      const std::string& filter_chain_type, absl::string_view stat_prefix)
+      : DynamicFilterConfigProviderImpl(subscription, require_type_urls, factory_context,
+                                        std::move(default_config), last_filter_in_filter_chain,
+                                        filter_chain_type, stat_prefix),
+        factory_context_(factory_context) {}
+
+  void validateMessage(const std::string&, const Protobuf::Message&,
+                       const std::string&) const override {}
+
+private:
+  Network::ListenerFilterFactoryCb
+  instantiateFilterFactory(const Protobuf::Message& message) const override {
+    auto* factory =
+        Registry::FactoryRegistry<Server::Configuration::NamedListenerFilterConfigFactory>::
+            getFactoryByType(message.GetTypeName());
+    return factory->createListenerFilterFactoryFromProto(message, nullptr, factory_context_);
+  }
+
+  Server::Configuration::ListenerFactoryContext& factory_context_;
 };
 
 /**
@@ -304,14 +343,14 @@ class FilterConfigProviderManagerImplBase : Logger::Loggable<Logger::Id::filter>
 /**
  * An implementation of FilterConfigProviderManager.
  */
-template <class FactoryCb>
+template <class Factory, class FactoryCb, class FactoryCt>
 class FilterConfigProviderManagerImpl : public FilterConfigProviderManagerImplBase,
-                                        public FilterConfigProviderManager<FactoryCb>,
+                                        public FilterConfigProviderManager<FactoryCb, FactoryCt>,
                                         public Singleton::Instance {
 public:
   DynamicFilterConfigProviderPtr<FactoryCb> createDynamicFilterConfigProvider(
       const envoy::config::core::v3::ExtensionConfigSource& config_source,
-      const std::string& filter_config_name, Server::Configuration::FactoryContext& factory_context,
+      const std::string& filter_config_name, FactoryCt& factory_context,
       const std::string& stat_prefix, bool last_filter_in_filter_chain,
       const std::string& filter_chain_type) override {
     std::string subscription_stat_prefix;
@@ -365,6 +404,16 @@ class FilterConfigProviderManagerImpl : public FilterConfigProviderManagerImplBa
     return std::make_unique<StaticFilterConfigProviderImpl<FactoryCb>>(config, filter_config_name);
   }
 
+  std::tuple<ProtobufTypes::MessagePtr, std::string>
+  getMessage(const envoy::config::core::v3::TypedExtensionConfig& filter_config,
+             Server::Configuration::ServerFactoryContext& factory_context) const override {
+    auto& factory = Config::Utility::getAndCheckFactory<Factory>(filter_config);
+    ProtobufTypes::MessagePtr message = Config::Utility::translateAnyToFactoryConfig(
+        filter_config.typed_config(),
+        factory_context.messageValidationContext().dynamicValidationVisitor(), factory);
+    return {std::move(message), factory.name()};
+  }
+
   absl::string_view statPrefix() const override PURE;
 
 protected:
@@ -378,20 +427,18 @@ class FilterConfigProviderManagerImpl : public FilterConfigProviderManagerImplBa
   virtual std::unique_ptr<DynamicFilterConfigProviderImpl<FactoryCb>>
   createFilterConfigProviderImpl(FilterConfigSubscriptionSharedPtr& subscription,
                                  const absl::flat_hash_set<std::string>& require_type_urls,
-                                 Server::Configuration::FactoryContext& factory_context,
+                                 FactoryCt& factory_context,
                                  ProtobufTypes::MessagePtr&& default_config,
                                  bool last_filter_in_filter_chain,
                                  const std::string& filter_chain_type,
                                  absl::string_view stat_prefix) PURE;
 };
 
 class HttpFilterConfigProviderManagerImpl
-    : public FilterConfigProviderManagerImpl<Http::FilterFactoryCb> {
+    : public FilterConfigProviderManagerImpl<Server::Configuration::NamedHttpFilterConfigFactory,
+                                             Http::FilterFactoryCb,
+                                             Server::Configuration::FactoryContext> {
 public:
-  std::tuple<ProtobufTypes::MessagePtr, std::string>
-  getMessage(const envoy::config::core::v3::TypedExtensionConfig& filter_config,
-             Server::Configuration::ServerFactoryContext& factory_context) const override;
-
   absl::string_view statPrefix() const override;
 
 protected:
@@ -416,5 +463,34 @@ class HttpFilterConfigProviderManagerImpl
   }
 };
 
+class ListenerFilterConfigProviderManagerImpl
+    : public FilterConfigProviderManagerImpl<
+          Server::Configuration::NamedListenerFilterConfigFactory, Network::ListenerFilterFactoryCb,
+          Server::Configuration::ListenerFactoryContext> {
+public:
+  absl::string_view statPrefix() const override;
+
+protected:
+  ProtobufTypes::MessagePtr
+  getDefaultConfig(const ProtobufWkt::Any& proto_config, const std::string& filter_config_name,
+                   Server::Configuration::FactoryContext& factory_context, bool,
+                   const std::string& filter_chain_type,
+                   const absl::flat_hash_set<std::string>& require_type_urls) const override;
+
+private:
+  std::unique_ptr<DynamicFilterConfigProviderImpl<Network::ListenerFilterFactoryCb>>
+  createFilterConfigProviderImpl(FilterConfigSubscriptionSharedPtr& subscription,
+                                 const absl::flat_hash_set<std::string>& require_type_urls,
+                                 Server::Configuration::ListenerFactoryContext& factory_context,
+                                 ProtobufTypes::MessagePtr&& default_config,
+                                 bool last_filter_in_filter_chain,
+                                 const std::string& filter_chain_type,
+                                 absl::string_view stat_prefix) override {
+    return std::make_unique<ListenerDynamicFilterConfigProviderImpl>(
+        subscription, require_type_urls, factory_context, std::move(default_config),
+        last_filter_in_filter_chain, filter_chain_type, stat_prefix);
+  }
+};
+
 } // namespace Filter
 } // namespace Envoy

source/extensions/filters/listener/tls_inspector/BUILD

@@ -42,6 +42,7 @@ envoy_cc_extension(
     extra_visibility = [
         "//test/integration:__subpackages__",
     ],
+    visibility = ["//visibility:public"],
     deps = [
         "//envoy/registry",
         "//envoy/server:filter_config_interface",

source/extensions/filters/network/http_connection_manager/config.h

@@ -39,7 +39,9 @@ namespace Extensions {
 namespace NetworkFilters {
 namespace HttpConnectionManager {
 
-using FilterConfigProviderManager = Filter::FilterConfigProviderManager<Http::FilterFactoryCb>;
+using FilterConfigProviderManager =
+    Filter::FilterConfigProviderManager<Http::FilterFactoryCb,
+                                        Server::Configuration::FactoryContext>;
 
 /**
  * Config registration for the HTTP connection manager filter. @see NamedNetworkFilterConfigFactory.

test/common/filter/BUILD

@@ -16,6 +16,7 @@ envoy_cc_test(
         "//source/common/filter:config_discovery_lib",
         "//source/common/json:json_loader_lib",
         "//source/extensions/filters/http/router:config",
+        "//source/extensions/filters/listener/tls_inspector:config",
         "//test/integration/filters:add_body_filter_config_lib",
         "//test/mocks/local_info:local_info_mocks",
         "//test/mocks/protobuf:protobuf_mocks",