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 FactoryCtx> 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, FactoryCtx& 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

@@ -16,19 +16,24 @@
 namespace Envoy {
 namespace Filter {
 
-constexpr absl::string_view HttpStatPrefix = "http_filter.";
+void validateProtoConfigDefaultFactoryHelper(const bool null_default_factory,
+                                             absl::string_view filter_config_name,
+                                             absl::string_view type_url) {
+  if (null_default_factory) {
+    throw EnvoyException(fmt::format("Error: cannot find filter factory {} for default filter "
+                                     "configuration with type URL {}.",
+                                     filter_config_name, type_url));
+  }
+}
 
-namespace {
-void validateTypeUrlHelper(const std::string& type_url,
-                           const absl::flat_hash_set<std::string> require_type_urls) {
+void validateProtoConfigTypeUrlHelper(absl::string_view type_url,
+                                      const absl::flat_hash_set<std::string>& require_type_urls) {
   if (!require_type_urls.contains(type_url)) {
     throw EnvoyException(fmt::format("Error: filter config has type URL {} but expect {}.",
                                      type_url, absl::StrJoin(require_type_urls, ", ")));
   }
 }
 
-} // namespace
-
 DynamicFilterConfigProviderImplBase::DynamicFilterConfigProviderImplBase(
     FilterConfigSubscriptionSharedPtr& subscription,
     const absl::flat_hash_set<std::string>& require_type_urls, bool last_filter_in_filter_chain,
@@ -53,7 +58,7 @@ DynamicFilterConfigProviderImplBase::~DynamicFilterConfigProviderImplBase() {
 }
 
 void DynamicFilterConfigProviderImplBase::validateTypeUrl(const std::string& type_url) const {
-  validateTypeUrlHelper(type_url, require_type_urls_);
+  validateProtoConfigTypeUrlHelper(type_url, require_type_urls_);
 }
 
 const std::string& DynamicFilterConfigProviderImplBase::name() { return subscription_->name(); }
@@ -232,42 +237,5 @@ 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(
-    const ProtobufWkt::Any& proto_config, const std::string& filter_config_name,
-    Server::Configuration::FactoryContext& factory_context, bool last_filter_in_filter_chain,
-    const std::string& filter_chain_type,
-    const absl::flat_hash_set<std::string>& require_type_urls) const {
-  auto* default_factory =
-      Config::Utility::getFactoryByType<Server::Configuration::NamedHttpFilterConfigFactory>(
-          proto_config);
-  if (default_factory == nullptr) {
-    throw EnvoyException(fmt::format("Error: cannot find 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);
-  Config::Utility::validateTerminalFilters(
-      filter_config_name, default_factory->name(), filter_chain_type,
-      default_factory->isTerminalFilterByProto(*message, factory_context),
-      last_filter_in_filter_chain);
-  return message;
-}
-
 } // namespace Filter
 } // namespace Envoy