router: add support for direct (non-proxied) http responses.

include/envoy/router/router.h

@@ -43,6 +43,20 @@ class RedirectEntry {
   virtual Http::Code redirectResponseCode() const PURE;
 };
 
+/**
+ * A routing primitive that specifies a direct (non-proxied) HTTP response .
+ */
+class DirectResponseEntry {
+public:
+  virtual ~DirectResponseEntry() {}
+
+  /**
+   * Returns the HTTP status code to return.
+   * @return Http::Code the response Code.
+   */
+  virtual Http::Code responseCode() const PURE;
+};
+
 /**
  * CorsPolicy for Route and VirtualHost.
  */
@@ -416,7 +430,7 @@ class Decorator {
 typedef std::unique_ptr<const Decorator> DecoratorConstPtr;
 
 /**
- * An interface that holds a RedirectEntry or a RouteEntry for a request.
+ * An interface that holds a RedirectEntry, DirectResponseEntry, or RouteEntry for a request.
  */
 class Route {
 public:
@@ -427,6 +441,11 @@ class Route {
    */
   virtual const RedirectEntry* redirectEntry() const PURE;
 
+  /**
+   * @return the direct response entry or nullptr if there is no direct response for the request.
+   */
+  virtual const DirectResponseEntry* directResponseEntry() const PURE;
+
   /**
    * @return the route entry or nullptr if there is no matching route for the request.
    */

source/common/config/rds_json.cc

@@ -236,15 +236,22 @@ void RdsJson::translateRoute(const Json::Object& json_route, envoy::api::v2::Rou
       throw EnvoyException("Redirect route entries must not have WebSockets set");
     }
   }
+  bool has_direct_response = false;
+  if (json_route.hasObject("status") || json_route.hasObject("body")) {
+    has_direct_response = true;
+    auto* direct_response = route.mutable_direct_response();
+    direct_response->set_status(json_route.getInteger("status"));
+  }
   const bool has_cluster = json_route.hasObject("cluster") ||
                            json_route.hasObject("cluster_header") ||
                            json_route.hasObject("weighted_clusters");
 
-  if (has_cluster && has_redirect) {
-    throw EnvoyException("routes must be either redirects or cluster targets");
-  } else if (!has_cluster && !has_redirect) {
-    throw EnvoyException(
-        "routes must have redirect or one of cluster/cluster_header/weighted_clusters");
+  if ((has_cluster && (has_redirect || has_direct_response)) ||
+      (has_redirect && has_direct_response)) {
+    throw EnvoyException("routes must be either redirects, direct responses, or cluster targets");
+  } else if (!has_cluster && !has_redirect && !has_direct_response) {
+    throw EnvoyException("routes must have redirect, direct response, or one of "
+                         "cluster/cluster_header/weighted_clusters");
   } else if (has_cluster) {
     auto* action = route.mutable_route();
 

source/common/http/async_client_impl.h

@@ -191,6 +191,7 @@ class AsyncStreamImpl : public AsyncClient::Stream,
 
     // Router::Route
     const Router::RedirectEntry* redirectEntry() const override { return nullptr; }
+    const Router::DirectResponseEntry* directResponseEntry() const override { return nullptr; }
     const Router::RouteEntry* routeEntry() const override { return &route_entry_; }
     const Router::Decorator* decorator() const override { return nullptr; }
 

source/common/json/config_schemas.cc

@@ -672,6 +672,7 @@ const std::string Json::Schema::ROUTE_ENTRY_CONFIGURATION_SCHEMA(R"EOF(
       "weighted_clusters": {"$ref" : "#/definitions/weighted_clusters"},
       "host_redirect" : {"type" : "string"},
       "path_redirect" : {"type" : "string"},
+      "status": {"type": "integer"},
       "prefix_rewrite" : {"type" : "string"},
       "host_rewrite" : {"type" : "string"},
       "auto_host_rewrite" : {"type" : "boolean"},

source/common/router/config_impl.cc

@@ -238,7 +238,8 @@ RouteEntryImplBase::RouteEntryImplBase(const VirtualHostImpl& vhost,
                                                        route.route().response_headers_to_remove())),
       opaque_config_(parseOpaqueConfig(route)), decorator_(parseDecorator(route)),
       redirect_response_code_(
-          ConfigUtility::parseRedirectResponseCode(route.redirect().response_code())) {
+          ConfigUtility::parseRedirectResponseCode(route.redirect().response_code())),
+      direct_response_code_(static_cast<Http::Code>(route.direct_response().status())) {
   if (route.route().has_metadata_match()) {
     const auto filter_it = route.route().metadata_match().filter_metadata().find(
         Envoy::Config::MetadataFilters::get().ENVOY_LB);
@@ -426,17 +427,29 @@ DecoratorConstPtr RouteEntryImplBase::parseDecorator(const envoy::api::v2::Route
 }
 
 const RedirectEntry* RouteEntryImplBase::redirectEntry() const {
-  // A route for a request can exclusively be a route entry or a redirect entry.
+  // A route for a request can exclusively be a route entry, a direct response entry,
+  // or a redirect entry.
   if (isRedirect()) {
     return this;
   } else {
     return nullptr;
   }
 }
 
+const DirectResponseEntry* RouteEntryImplBase::directResponseEntry() const {
+  // A route for a request can exclusively be a route entry, a direct response entry,
+  // or a redirect entry.
+  if (isDirectResponse()) {
+    return this;
+  } else {
+    return nullptr;
+  }
+}
+
 const RouteEntry* RouteEntryImplBase::routeEntry() const {
-  // A route for a request can exclusively be a route entry or a redirect entry.
-  if (isRedirect()) {
+  // A route for a request can exclusively be a route entry, a direct response entry,
+  // or a redirect entry.
+  if (isRedirect() || isDirectResponse()) {
     return nullptr;
   } else {
     return this;
@@ -448,7 +461,7 @@ RouteConstSharedPtr RouteEntryImplBase::clusterEntry(const Http::HeaderMap& head
   // Gets the route object chosen from the list of weighted clusters
   // (if there is one) or returns self.
   if (weighted_clusters_.empty()) {
-    if (!cluster_name_.empty() || isRedirect()) {
+    if (!cluster_name_.empty() || isRedirect() || isDirectResponse()) {
       return shared_from_this();
     } else {
       ASSERT(!cluster_header_name_.get().empty());
@@ -489,7 +502,7 @@ RouteConstSharedPtr RouteEntryImplBase::clusterEntry(const Http::HeaderMap& head
 }
 
 void RouteEntryImplBase::validateClusters(Upstream::ClusterManager& cm) const {
-  if (isRedirect()) {
+  if (isRedirect() || isDirectResponse()) {
     return;
   }
 

source/common/router/config_impl.h

@@ -60,6 +60,7 @@ class SslRedirectRoute : public Route {
 public:
   // Router::Route
   const RedirectEntry* redirectEntry() const override { return &SSL_REDIRECTOR; }
+  const DirectResponseEntry* directResponseEntry() const override { return nullptr; }
   const RouteEntry* routeEntry() const override { return nullptr; }
   const Decorator* decorator() const override { return nullptr; }
 
@@ -287,13 +288,15 @@ class DecoratorImpl : public Decorator {
 class RouteEntryImplBase : public RouteEntry,
                            public Matchable,
                            public RedirectEntry,
+                           public DirectResponseEntry,
                            public Route,
                            public std::enable_shared_from_this<RouteEntryImplBase> {
 public:
   RouteEntryImplBase(const VirtualHostImpl& vhost, const envoy::api::v2::Route& route,
                      Runtime::Loader& loader);
 
   bool isRedirect() const { return !host_redirect_.empty() || !path_redirect_.empty(); }
+  bool isDirectResponse() const { return static_cast<int>(direct_response_code_) != 0; }
 
   bool matchRoute(const Http::HeaderMap& headers, uint64_t random_value) const;
   void validateClusters(Upstream::ClusterManager& cm) const;
@@ -333,8 +336,12 @@ class RouteEntryImplBase : public RouteEntry,
   std::string newPath(const Http::HeaderMap& headers) const override;
   Http::Code redirectResponseCode() const override { return redirect_response_code_; }
 
+  // Router::DirectResponseEntry
+  Http::Code responseCode() const override { return direct_response_code_; }
+
   // Router::Route
   const RedirectEntry* redirectEntry() const override;
+  const DirectResponseEntry* directResponseEntry() const override;
   const RouteEntry* routeEntry() const override;
   const Decorator* decorator() const override { return decorator_.get(); }
 
@@ -403,6 +410,7 @@ class RouteEntryImplBase : public RouteEntry,
 
     // Router::Route
     const RedirectEntry* redirectEntry() const override { return nullptr; }
+    const DirectResponseEntry* directResponseEntry() const override { return nullptr; }
     const RouteEntry* routeEntry() const override { return this; }
     const Decorator* decorator() const override { return nullptr; }
 
@@ -488,6 +496,7 @@ class RouteEntryImplBase : public RouteEntry,
 
   const DecoratorConstPtr decorator_;
   const Http::Code redirect_response_code_;
+  const Http::Code direct_response_code_;
 };
 
 /**

source/common/router/router.cc

@@ -217,6 +217,21 @@ Http::FilterHeadersStatus Filter::decodeHeaders(Http::HeaderMap& headers, bool e
     return Http::FilterHeadersStatus::StopIteration;
   }
 
+  // Determine if there is a direct response for the request.
+  if (route_->directResponseEntry()) {
+    Http::Utility::sendLocalReply(
+        [this](Http::HeaderMapPtr&& headers, bool end_stream) -> void {
+          // TODO(brian-pane) add response_headers_to_add to the headers here
+          callbacks_->encodeHeaders(std::move(headers), end_stream);
+        },
+        [this](Buffer::Instance& data, bool end_stream) -> void {
+          callbacks_->encodeData(data, end_stream);
+        },
+        stream_destroyed_, route_->directResponseEntry()->responseCode(), "");
+    // TODO(brian-pane) support sending a response body.
+    return Http::FilterHeadersStatus::StopIteration;
+  }
+
   // A route entry matches for the request.
   route_entry_ = route_->routeEntry();
   Upstream::ThreadLocalCluster* cluster = config_.cm_.get(route_entry_->clusterName());

source/common/ssl/context_config_impl.cc

@@ -114,6 +114,10 @@ ServerContextConfigImpl::ServerContextConfigImpl(const envoy::api::v2::Downstrea
               validateAndAppendKey(ret, datasource.inline_bytes());
               break;
             }
+            case envoy::api::v2::DataSource::kInlineString: {
+              validateAndAppendKey(ret, datasource.inline_string());
+              break;
+            }
             default:
               throw EnvoyException(fmt::format("Unexpected DataSource::specifier_case(): {}",
                                                datasource.specifier_case()));

test/common/router/config_impl_test.cc

@@ -2113,6 +2113,41 @@ TEST(RouteMatcherTest, Redirect) {
   }
 }
 
+TEST(RouteMatcherTest, DirectResponse) {
+  std::string json = R"EOF(
+{
+  "virtual_hosts": [
+    {
+      "name": "www",
+      "domains": ["www.example.com"],
+      "routes": [
+        {
+          "prefix": "/direct",
+          "status": 200
+        },
+        {
+          "prefix": "/",
+          "cluster": "www"
+        }
+      ]
+    }
+  ]
+}
+  )EOF";
+
+  NiceMock<Runtime::MockLoader> runtime;
+  NiceMock<Upstream::MockClusterManager> cm;
+  ConfigImpl config(parseRouteConfigurationFromJson(json), runtime, cm, true);
+
+  EXPECT_EQ("www", config.route(genHeaders("www.example.com", "/example", "GET"), 0)
+                       ->routeEntry()
+                       ->clusterName());
+  EXPECT_EQ(static_cast<Http::Code>(200),
+            config.route(genHeaders("www.example.com", "/direct", "GET"), 0)
+                ->directResponseEntry()
+                ->responseCode());
+}
+
 TEST(RouteMatcherTest, ExclusiveRouteEntryOrRedirectEntry) {
   std::string json = R"EOF(
 {
@@ -2726,9 +2761,10 @@ TEST(BadHttpRouteConfigurationsTest, BadRouteEntryConfigNoRedirectNoClusters) {
   NiceMock<Runtime::MockLoader> runtime;
   NiceMock<Upstream::MockClusterManager> cm;
 
-  EXPECT_THROW_WITH_MESSAGE(
-      ConfigImpl(parseRouteConfigurationFromJson(json), runtime, cm, true), EnvoyException,
-      "routes must have redirect or one of cluster/cluster_header/weighted_clusters")
+  EXPECT_THROW_WITH_MESSAGE(ConfigImpl(parseRouteConfigurationFromJson(json), runtime, cm, true),
+                            EnvoyException,
+                            "routes must have redirect, direct response, or "
+                            "one of cluster/cluster_header/weighted_clusters")
 }
 
 TEST(RouteMatcherTest, TestOpaqueConfig) {

test/common/router/router_test.cc

@@ -1476,6 +1476,19 @@ TEST_F(RouterTest, RedirectFound) {
   EXPECT_TRUE(verifyHostUpstreamStats(0, 0));
 }
 
+TEST_F(RouterTest, DirectResponse) {
+  MockDirectResponseEntry direct_response;
+  EXPECT_CALL(direct_response, responseCode()).WillOnce(Return(Http::Code::OK));
+  EXPECT_CALL(*callbacks_.route_, directResponseEntry()).WillRepeatedly(Return(&direct_response));
+
+  Http::TestHeaderMapImpl response_headers{{":status", "200"}};
+  EXPECT_CALL(callbacks_, encodeHeaders_(HeaderMapEqualRef(&response_headers), true));
+  Http::TestHeaderMapImpl headers;
+  HttpTestUtility::addDefaultHeaders(headers);
+  router_.decodeHeaders(headers, true);
+  EXPECT_TRUE(verifyHostUpstreamStats(0, 0));
+}
+
 TEST(RouterFilterUtilityTest, finalTimeout) {
   {
     NiceMock<MockRouteEntry> route;

test/common/ssl/context_impl_test.cc

@@ -248,23 +248,41 @@ TEST_F(SslServerContextImplTicketTest, TicketKeyNone) {
   EXPECT_NO_THROW(loadConfigV2(cfg));
 }
 
-TEST_F(SslServerContextImplTicketTest, TicketKeyInlineSuccess) {
+TEST_F(SslServerContextImplTicketTest, TicketKeyInlineBytesSuccess) {
   envoy::api::v2::DownstreamTlsContext cfg;
   cfg.mutable_session_ticket_keys()->add_keys()->set_inline_bytes(std::string(80, '\0'));
   EXPECT_NO_THROW(loadConfigV2(cfg));
 }
 
-TEST_F(SslServerContextImplTicketTest, TicketKeyInlineFailTooBig) {
+TEST_F(SslServerContextImplTicketTest, TicketKeyInlineStringSuccess) {
+  envoy::api::v2::DownstreamTlsContext cfg;
+  cfg.mutable_session_ticket_keys()->add_keys()->set_inline_string(std::string(80, '\0'));
+  EXPECT_NO_THROW(loadConfigV2(cfg));
+}
+
+TEST_F(SslServerContextImplTicketTest, TicketKeyInlineBytesFailTooBig) {
   envoy::api::v2::DownstreamTlsContext cfg;
   cfg.mutable_session_ticket_keys()->add_keys()->set_inline_bytes(std::string(81, '\0'));
   EXPECT_THROW(loadConfigV2(cfg), EnvoyException);
 }
 
-TEST_F(SslServerContextImplTicketTest, TicketKeyInlineFailTooSmall) {
+TEST_F(SslServerContextImplTicketTest, TicketKeyInlineStringFailTooBig) {
+  envoy::api::v2::DownstreamTlsContext cfg;
+  cfg.mutable_session_ticket_keys()->add_keys()->set_inline_string(std::string(81, '\0'));
+  EXPECT_THROW(loadConfigV2(cfg), EnvoyException);
+}
+
+TEST_F(SslServerContextImplTicketTest, TicketKeyInlineBytesFailTooSmall) {
   envoy::api::v2::DownstreamTlsContext cfg;
   cfg.mutable_session_ticket_keys()->add_keys()->set_inline_bytes(std::string(79, '\0'));
   EXPECT_THROW(loadConfigV2(cfg), EnvoyException);
 }
 
+TEST_F(SslServerContextImplTicketTest, TicketKeyInlineStringFailTooSmall) {
+  envoy::api::v2::DownstreamTlsContext cfg;
+  cfg.mutable_session_ticket_keys()->add_keys()->set_inline_string(std::string(79, '\0'));
+  EXPECT_THROW(loadConfigV2(cfg), EnvoyException);
+}
+
 } // namespace Ssl
 } // namespace Envoy

test/config/utility.cc

@@ -226,6 +226,23 @@ void ConfigHelper::addRoute(const std::string& domains, const std::string& prefi
   storeHttpConnectionManager(hcm_config);
 }
 
+void ConfigHelper::addDirectResponse(const std::string& domains, const std::string& prefix,
+                                     Http::Code status, const std::string&) {
+  RELEASE_ASSERT(!finalized_);
+  envoy::api::v2::filter::network::HttpConnectionManager hcm_config;
+  loadHttpConnectionManager(hcm_config);
+
+  auto* route_config = hcm_config.mutable_route_config();
+  auto* virtual_host = route_config->add_virtual_hosts();
+  virtual_host->set_name(domains);
+  virtual_host->add_domains(domains);
+  virtual_host->add_routes()->mutable_match()->set_prefix(prefix);
+  virtual_host->mutable_routes(0)->mutable_direct_response()->set_status(
+      static_cast<uint32_t>(status));
+
+  storeHttpConnectionManager(hcm_config);
+}
+
 void ConfigHelper::addFilter(const std::string& config) {
   RELEASE_ASSERT(!finalized_);
   envoy::api::v2::filter::network::HttpConnectionManager hcm_config;

test/config/utility.h

@@ -5,6 +5,8 @@
 #include <string>
 #include <vector>
 
+#include "envoy/http/codes.h"
+
 #include "common/network/address_impl.h"
 
 #include "api/base.pb.h"
@@ -67,6 +69,10 @@ class ConfigHelper {
       bool validate_clusters, envoy::api::v2::RouteAction::ClusterNotFoundResponseCode code,
       envoy::api::v2::VirtualHost::TlsRequirementType type = envoy::api::v2::VirtualHost::NONE);
 
+  // Add an additional route with a direct (non-proxied) response.
+  void addDirectResponse(const std::string& domains, const std::string& prefix,
+                         Http::Code responseCode, const std::string& body);
+
   // Add an HTTP filter prior to existing filters.
   void addFilter(const std::string& filter_yaml);