Route-local fault filter config

source/extensions/filters/http/fault/config.cc

@@ -42,6 +42,14 @@ FaultFilterFactory::createFilterFactoryFromProto(const Protobuf::Message& proto_
       stats_prefix, context);
 }
 
+Router::RouteSpecificFilterConfigConstSharedPtr
+FaultFilterFactory::createRouteSpecificFilterConfig(const ProtobufWkt::Struct& struct_config) {
+  envoy::config::filter::http::fault::v2::HTTPFault proto_config;
+  MessageUtil::jsonConvert(struct_config, proto_config);
+  return std::make_shared<const Router::RouteSpecificFilterConfig>(
+      Fault::FaultSettings(proto_config));
+}
+
 /**
  * Static registration for the fault filter. @see RegisterFactory.
  */

source/extensions/filters/http/fault/config.h

@@ -27,6 +27,9 @@ class FaultFilterFactory : public Server::Configuration::NamedHttpFilterConfigFa
     return ProtobufTypes::MessagePtr{new envoy::config::filter::http::fault::v2::HTTPFault()};
   }
 
+  Router::RouteSpecificFilterConfigConstSharedPtr
+  createRouteSpecificFilterConfig(const ProtobufWkt::Struct&) override;
+
   std::string name() override { return HttpFilterNames::get().FAULT; }
 
 private:

source/extensions/filters/http/fault/fault_filter.cc

@@ -20,6 +20,8 @@
 #include "common/protobuf/utility.h"
 #include "common/router/config_impl.h"
 
+#include "extensions/filters/http/well_known_names.h"
+
 namespace Envoy {
 namespace Extensions {
 namespace HttpFilters {
@@ -30,15 +32,7 @@ const std::string FaultFilter::ABORT_PERCENT_KEY = "fault.http.abort.abort_perce
 const std::string FaultFilter::DELAY_DURATION_KEY = "fault.http.delay.fixed_duration_ms";
 const std::string FaultFilter::ABORT_HTTP_STATUS_KEY = "fault.http.abort.http_status";
 
-FaultFilterConfig::FaultFilterConfig(const envoy::config::filter::http::fault::v2::HTTPFault& fault,
-                                     Runtime::Loader& runtime, const std::string& stats_prefix,
-                                     Stats::Scope& scope)
-    : runtime_(runtime), stats_(generateStats(stats_prefix, scope)), stats_prefix_(stats_prefix),
-      scope_(scope) {
-
-  if (!fault.has_abort() && !fault.has_delay()) {
-    throw EnvoyException("fault filter must have at least abort or delay specified in the config.");
-  }
+FaultSettings::FaultSettings(const envoy::config::filter::http::fault::v2::HTTPFault& fault) {
 
   if (fault.has_abort()) {
     abort_percent_ = fault.abort().percent();
@@ -62,6 +56,12 @@ FaultFilterConfig::FaultFilterConfig(const envoy::config::filter::http::fault::v
   }
 }
 
+FaultFilterConfig::FaultFilterConfig(const envoy::config::filter::http::fault::v2::HTTPFault& fault,
+                                     Runtime::Loader& runtime, const std::string& stats_prefix,
+                                     Stats::Scope& scope)
+    : settings_(fault), runtime_(runtime), stats_(generateStats(stats_prefix, scope)),
+      stats_prefix_(stats_prefix), scope_(scope) {}
+
 FaultFilter::FaultFilter(FaultFilterConfigSharedPtr config) : config_(config) {}
 
 FaultFilter::~FaultFilter() { ASSERT(!delay_timer_); }
@@ -71,6 +71,21 @@ FaultFilter::~FaultFilter() { ASSERT(!delay_timer_); }
 // if we inject a delay, then we will inject the abort in the delay timer
 // callback.
 Http::FilterHeadersStatus FaultFilter::decodeHeaders(Http::HeaderMap& headers, bool) {
+  // Route-level configuration overrides filter-level configuration
+  // NOTE: We should not use runtime when reading from route-level
+  // faults. In other words, runtime is supported only when faults are
+  // configured at the filter level.
+  fault_settings_ = config_->settings();
+  if (callbacks_->route() && callbacks_->route()->routeEntry()) {
+    const std::string& name = Extensions::HttpFilters::HttpFilterNames::get().FAULT;
+    const auto* route_entry = callbacks_->route()->routeEntry();
+
+    const FaultSettings* per_route_settings_ =
+        route_entry->perFilterConfigTyped<FaultSettings>(name)
+            ?: route_entry->virtualHost().perFilterConfigTyped<FaultSettings>(name);
+    fault_settings_ = per_route_settings_ ?: fault_settings_;
+  }
+
   if (!matchesTargetUpstreamCluster()) {
     return Http::FilterHeadersStatus::Continue;
   }
@@ -80,7 +95,7 @@ Http::FilterHeadersStatus FaultFilter::decodeHeaders(Http::HeaderMap& headers, b
   }
 
   // Check for header matches
-  if (!Router::ConfigUtility::matchHeaders(headers, config_->filterHeaders())) {
+  if (!Router::ConfigUtility::matchHeaders(headers, fault_settings_->filterHeaders())) {
     return Http::FilterHeadersStatus::Continue;
   }
 
@@ -115,24 +130,24 @@ Http::FilterHeadersStatus FaultFilter::decodeHeaders(Http::HeaderMap& headers, b
 }
 
 bool FaultFilter::isDelayEnabled() {
-  bool enabled =
-      config_->runtime().snapshot().featureEnabled(DELAY_PERCENT_KEY, config_->delayPercent());
+  bool enabled = config_->runtime().snapshot().featureEnabled(DELAY_PERCENT_KEY,
+                                                              fault_settings_->delayPercent());
 
   if (!downstream_cluster_delay_percent_key_.empty()) {
     enabled |= config_->runtime().snapshot().featureEnabled(downstream_cluster_delay_percent_key_,
-                                                            config_->delayPercent());
+                                                            fault_settings_->delayPercent());
   }
 
   return enabled;
 }
 
 bool FaultFilter::isAbortEnabled() {
-  bool enabled =
-      config_->runtime().snapshot().featureEnabled(ABORT_PERCENT_KEY, config_->abortPercent());
+  bool enabled = config_->runtime().snapshot().featureEnabled(ABORT_PERCENT_KEY,
+                                                              fault_settings_->abortPercent());
 
   if (!downstream_cluster_abort_percent_key_.empty()) {
     enabled |= config_->runtime().snapshot().featureEnabled(downstream_cluster_abort_percent_key_,
-                                                            config_->abortPercent());
+                                                            fault_settings_->abortPercent());
   }
 
   return enabled;
@@ -145,8 +160,8 @@ absl::optional<uint64_t> FaultFilter::delayDuration() {
     return ret;
   }
 
-  uint64_t duration =
-      config_->runtime().snapshot().getInteger(DELAY_DURATION_KEY, config_->delayDuration());
+  uint64_t duration = config_->runtime().snapshot().getInteger(DELAY_DURATION_KEY,
+                                                               fault_settings_->delayDuration());
   if (!downstream_cluster_delay_duration_key_.empty()) {
     duration =
         config_->runtime().snapshot().getInteger(downstream_cluster_delay_duration_key_, duration);
@@ -163,7 +178,7 @@ absl::optional<uint64_t> FaultFilter::delayDuration() {
 uint64_t FaultFilter::abortHttpStatus() {
   // TODO(mattklein123): check http status codes obtained from runtime.
   uint64_t http_status =
-      config_->runtime().snapshot().getInteger(ABORT_HTTP_STATUS_KEY, config_->abortCode());
+      config_->runtime().snapshot().getInteger(ABORT_HTTP_STATUS_KEY, fault_settings_->abortCode());
 
   if (!downstream_cluster_abort_http_status_key_.empty()) {
     http_status = config_->runtime().snapshot().getInteger(
@@ -244,17 +259,17 @@ void FaultFilter::abortWithHTTPStatus() {
 bool FaultFilter::matchesTargetUpstreamCluster() {
   bool matches = true;
 
-  if (!config_->upstreamCluster().empty()) {
+  if (!fault_settings_->upstreamCluster().empty()) {
     Router::RouteConstSharedPtr route = callbacks_->route();
     matches = route && route->routeEntry() &&
-              (route->routeEntry()->clusterName() == config_->upstreamCluster());
+              (route->routeEntry()->clusterName() == fault_settings_->upstreamCluster());
   }
 
   return matches;
 }
 
 bool FaultFilter::matchesDownstreamNodes(const Http::HeaderMap& headers) {
-  if (config_->downstreamNodes().empty()) {
+  if (fault_settings_->downstreamNodes().empty()) {
     return true;
   }
 
@@ -263,7 +278,8 @@ bool FaultFilter::matchesDownstreamNodes(const Http::HeaderMap& headers) {
   }
 
   const std::string downstream_node = headers.EnvoyDownstreamServiceNode()->value().c_str();
-  return config_->downstreamNodes().find(downstream_node) != config_->downstreamNodes().end();
+  return fault_settings_->downstreamNodes().find(downstream_node) !=
+         fault_settings_->downstreamNodes().end();
 }
 
 void FaultFilter::resetTimerState() {

source/extensions/filters/http/fault/fault_filter.h

@@ -35,6 +35,33 @@ struct FaultFilterStats {
   ALL_FAULT_FILTER_STATS(GENERATE_COUNTER_STRUCT)
 };
 
+/**
+ * Configuration for fault injection.
+ */
+class FaultSettings : public Router::RouteSpecificFilterConfig {
+public:
+  FaultSettings(const envoy::config::filter::http::fault::v2::HTTPFault& fault);
+
+  const std::vector<Router::ConfigUtility::HeaderData>& filterHeaders() const {
+    return fault_filter_headers_;
+  }
+  uint64_t abortPercent() const { return abort_percent_; }
+  uint64_t delayPercent() const { return fixed_delay_percent_; }
+  uint64_t delayDuration() const { return fixed_duration_ms_; }
+  uint64_t abortCode() const { return http_status_; }
+  const std::string& upstreamCluster() const { return upstream_cluster_; }
+  const std::unordered_set<std::string>& downstreamNodes() const { return downstream_nodes_; }
+
+private:
+  uint64_t abort_percent_{};       // 0-100
+  uint64_t http_status_{};         // HTTP or gRPC return codes
+  uint64_t fixed_delay_percent_{}; // 0-100
+  uint64_t fixed_duration_ms_{};   // in milliseconds
+  std::string upstream_cluster_;   // restrict faults to specific upstream cluster
+  std::vector<Router::ConfigUtility::HeaderData> fault_filter_headers_;
+  std::unordered_set<std::string> downstream_nodes_{}; // Inject failures for specific downstream
+};
+
 /**
  * Configuration for the fault filter.
  */
@@ -43,31 +70,16 @@ class FaultFilterConfig {
   FaultFilterConfig(const envoy::config::filter::http::fault::v2::HTTPFault& fault,
                     Runtime::Loader& runtime, const std::string& stats_prefix, Stats::Scope& scope);
 
-  const std::vector<Router::ConfigUtility::HeaderData>& filterHeaders() {
-    return fault_filter_headers_;
-  }
-  uint64_t abortPercent() { return abort_percent_; }
-  uint64_t delayPercent() { return fixed_delay_percent_; }
-  uint64_t delayDuration() { return fixed_duration_ms_; }
-  uint64_t abortCode() { return http_status_; }
-  const std::string& upstreamCluster() { return upstream_cluster_; }
   Runtime::Loader& runtime() { return runtime_; }
   FaultFilterStats& stats() { return stats_; }
-  const std::unordered_set<std::string>& downstreamNodes() { return downstream_nodes_; }
   const std::string& statsPrefix() { return stats_prefix_; }
   Stats::Scope& scope() { return scope_; }
+  const FaultSettings* settings() { return &settings_; }
 
 private:
   static FaultFilterStats generateStats(const std::string& prefix, Stats::Scope& scope);
 
-  uint64_t abort_percent_{};       // 0-100
-  uint64_t http_status_{};         // HTTP or gRPC return codes
-  uint64_t fixed_delay_percent_{}; // 0-100
-  uint64_t fixed_duration_ms_{};   // in milliseconds
-  std::string upstream_cluster_;   // restrict faults to specific upstream cluster
-  std::vector<Router::ConfigUtility::HeaderData> fault_filter_headers_;
-  std::unordered_set<std::string> downstream_nodes_{}; // Inject failures for specific downstream
-                                                       // nodes. If not set then inject for all.
+  const FaultSettings settings_;
   Runtime::Loader& runtime_;
   FaultFilterStats stats_;
   const std::string stats_prefix_;
@@ -112,6 +124,7 @@ class FaultFilter : public Http::StreamDecoderFilter {
   Event::TimerPtr delay_timer_;
   std::string downstream_cluster_{};
   bool stream_destroyed_{};
+  const FaultSettings* fault_settings_;
 
   std::string downstream_cluster_delay_percent_key_{};
   std::string downstream_cluster_abort_percent_key_{};

test/extensions/filters/http/fault/config_test.cc

@@ -56,19 +56,14 @@ TEST(FaultFilterConfigTest, FaultFilterCorrectProto) {
   cb(filter_callback);
 }
 
-TEST(FaultFilterConfigTest, InvalidFaultFilterInProto) {
-  envoy::config::filter::http::fault::v2::HTTPFault config{};
-  NiceMock<Server::Configuration::MockFactoryContext> context;
-  FaultFilterFactory factory;
-  EXPECT_THROW(factory.createFilterFactoryFromProto(config, "stats", context), EnvoyException);
-}
-
 TEST(FaultFilterConfigTest, FaultFilterEmptyProto) {
   NiceMock<Server::Configuration::MockFactoryContext> context;
   FaultFilterFactory factory;
-  EXPECT_THROW(
-      factory.createFilterFactoryFromProto(*factory.createEmptyConfigProto(), "stats", context),
-      EnvoyException);
+  Server::Configuration::HttpFilterFactoryCb cb =
+      factory.createFilterFactoryFromProto(*factory.createEmptyConfigProto(), "stats", context);
+  Http::MockFilterChainFactoryCallbacks filter_callback;
+  EXPECT_CALL(filter_callback, addStreamDecoderFilter(_));
+  cb(filter_callback);
 }
 
 } // namespace Fault