Expose fault.http.abort.http_status setting via HTTP header

docs/root/configuration/http/http_filters/fault_filter.rst

@@ -38,7 +38,7 @@ fault configuration. The currently supported header controls are:
 
 * Request abort configuration via the *x-envoy-fault-abort-request* header. The header value
   should be an integer that specifies the HTTP status code to return in response to a request
-  and must be in the range [100, 600).
+  and must be in the range [200, 600).
 * Request delay configuration via the *x-envoy-fault-delay-request* header. The header value
   should be an integer that specifies the number of milliseconds to throttle the latency for.
 * Response rate limit configuration via the *x-envoy-fault-throughput-response* header. The

source/extensions/filters/common/fault/fault_config.cc

@@ -27,17 +27,22 @@ FaultAbortConfig::FaultAbortConfig(
 }
 
 absl::optional<Http::Code>
-FaultAbortConfig::HeaderAbortProvider::status_code(const Http::HeaderEntry* header) const {
+FaultAbortConfig::HeaderAbortProvider::statusCode(const Http::HeaderEntry* header) const {
+  absl::optional<Http::Code> ret;
   if (header == nullptr) {
-    return absl::nullopt;
+    return ret;
   }
 
-  uint64_t value;
-  if (!absl::SimpleAtoi(header->value().getStringView(), &value)) {
-    return absl::nullopt;
+  uint64_t code;
+  if (!absl::SimpleAtoi(header->value().getStringView(), &code)) {
+    return ret;
+  }
+
+  if (code >= 200 and code < 600) {
+    ret = static_cast<Http::Code>(code);
   }
 
-  return static_cast<Http::Code>(value);
+  return ret;
 }
 
 FaultDelayConfig::FaultDelayConfig(

source/extensions/filters/common/fault/fault_config.h

@@ -32,8 +32,8 @@ class FaultAbortConfig {
   FaultAbortConfig(const envoy::extensions::filters::http::fault::v3::FaultAbort& abort_config);
 
   const envoy::type::v3::FractionalPercent& percentage() const { return percentage_; }
-  absl::optional<Http::Code> status_code(const Http::HeaderEntry* header) const {
-    return provider_->status_code(header);
+  absl::optional<Http::Code> statusCode(const Http::HeaderEntry* header) const {
+    return provider_->statusCode(header);
   }
 
 private:
@@ -44,28 +44,28 @@ class FaultAbortConfig {
 
     // Return the HTTP status code to use. Optionally passed an HTTP header that may contain the
     // HTTP status code depending on the provider implementation.
-    virtual absl::optional<Http::Code> status_code(const Http::HeaderEntry* header) const PURE;
+    virtual absl::optional<Http::Code> statusCode(const Http::HeaderEntry* header) const PURE;
   };
 
-  // Delay provider that uses a fixed delay.
+  // Delay provider that uses a fixed abort status code.
   class FixedAbortProvider : public AbortProvider {
   public:
     FixedAbortProvider(uint64_t status_code) : status_code_(status_code) {}
 
-    // DelayProvider
-    absl::optional<Http::Code> status_code(const Http::HeaderEntry*) const override {
+    // AbortProvider
+    absl::optional<Http::Code> statusCode(const Http::HeaderEntry*) const override {
       return static_cast<Http::Code>(status_code_);
     }
 
   private:
     const uint64_t status_code_;
   };
 
-  // Abort provider the reads a delay from an HTTP header.
+  // Abort provider the reads a status code from an HTTP header.
   class HeaderAbortProvider : public AbortProvider {
   public:
     // AbortProvider
-    absl::optional<Http::Code> status_code(const Http::HeaderEntry* header) const override;
+    absl::optional<Http::Code> statusCode(const Http::HeaderEntry* header) const override;
   };
 
   using AbortProviderPtr = std::unique_ptr<AbortProvider>;

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

@@ -164,7 +164,7 @@ Http::FilterHeadersStatus FaultFilter::decodeHeaders(Http::RequestHeaderMap& hea
     return Http::FilterHeadersStatus::StopIteration;
   }
 
-  auto abort_code = abortHttpStatus(headers);
+  const auto abort_code = abortHttpStatus(headers);
   if (abort_code.has_value()) {
     abortWithHTTPStatus(abort_code.value());
     return Http::FilterHeadersStatus::StopIteration;
@@ -222,29 +222,31 @@ bool FaultFilter::faultOverflow() {
 }
 
 bool FaultFilter::isDelayEnabled() {
-  if (fault_settings_->requestDelay() == nullptr) {
+  const auto request_delay = fault_settings_->requestDelay();
+  if (request_delay == nullptr) {
     return false;
   }
 
   if (!downstream_cluster_delay_percent_key_.empty()) {
-    return config_->runtime().snapshot().featureEnabled(
-        downstream_cluster_delay_percent_key_, fault_settings_->requestDelay()->percentage());
+    return config_->runtime().snapshot().featureEnabled(downstream_cluster_delay_percent_key_,
+                                                        request_delay->percentage());
   }
-  return config_->runtime().snapshot().featureEnabled(
-      fault_settings_->delayPercentRuntime(), fault_settings_->requestDelay()->percentage());
+  return config_->runtime().snapshot().featureEnabled(fault_settings_->delayPercentRuntime(),
+                                                      request_delay->percentage());
 }
 
 bool FaultFilter::isAbortEnabled() {
-  if (fault_settings_->requestAbort() == nullptr) {
+  const auto request_abort = fault_settings_->requestAbort();
+  if (request_abort == nullptr) {
     return false;
   }
 
   if (!downstream_cluster_abort_percent_key_.empty()) {
-    return config_->runtime().snapshot().featureEnabled(
-        downstream_cluster_abort_percent_key_, fault_settings_->requestAbort()->percentage());
+    return config_->runtime().snapshot().featureEnabled(downstream_cluster_abort_percent_key_,
+                                                        request_abort->percentage());
   }
-  return config_->runtime().snapshot().featureEnabled(
-      fault_settings_->abortPercentRuntime(), fault_settings_->requestAbort()->percentage());
+  return config_->runtime().snapshot().featureEnabled(fault_settings_->abortPercentRuntime(),
+                                                      request_abort->percentage());
 }
 
 absl::optional<std::chrono::milliseconds>
@@ -287,7 +289,7 @@ FaultFilter::abortHttpStatus(const Http::RequestHeaderMap& request_headers) {
 
   // See if the configured abort provider has a default status code, if not there is no abort status
   // code (e.g., header configuration and no/invalid header).
-  auto config_abort = fault_settings_->requestAbort()->status_code(
+  const auto config_abort = fault_settings_->requestAbort()->statusCode(
       request_headers.get(Filters::Common::Fault::HeaderNames::get().AbortRequest));
   if (!config_abort.has_value()) {
     return absl::nullopt;

test/extensions/filters/common/fault/fault_config_test.cc

@@ -19,16 +19,16 @@ TEST(FaultConfigTest, FaultAbortHeaderConfig) {
   FaultAbortConfig config(proto_config);
 
   // No header.
-  EXPECT_EQ(absl::nullopt, config.status_code(nullptr));
+  EXPECT_EQ(absl::nullopt, config.statusCode(nullptr));
 
   // Header with bad data.
   Http::TestHeaderMapImpl bad_headers{{"x-envoy-fault-abort-request", "abc"}};
-  EXPECT_EQ(absl::nullopt, config.status_code(bad_headers.get(HeaderNames::get().AbortRequest)));
+  EXPECT_EQ(absl::nullopt, config.statusCode(bad_headers.get(HeaderNames::get().AbortRequest)));
 
   // Valid header.
   Http::TestHeaderMapImpl good_headers{{"x-envoy-fault-abort-request", "401"}};
   EXPECT_EQ(Http::Code::Unauthorized,
-            config.status_code(good_headers.get(HeaderNames::get().AbortRequest)).value());
+            config.statusCode(good_headers.get(HeaderNames::get().AbortRequest)).value());
 }
 
 TEST(FaultConfigTest, FaultDelayHeaderConfig) {