envoyproxy · mattklein123 · Feb 27, 2017 · Feb 17, 2017 · Feb 20, 2017 · Feb 20, 2017
diff --git a/docs/configuration/http_conn_man/route_config/route.rst b/docs/configuration/http_conn_man/route_config/route.rst
@@ -18,6 +18,7 @@ next (e.g., redirect, forward, rewrite, etc.).
     "path_redirect": "...",
     "prefix_rewrite": "...",
     "host_rewrite": "...",
+    "auto_host_rewrite": "...",
     "case_sensitive": "...",
     "timeout_ms": "...",
     "runtime": "{...}",
@@ -98,6 +99,15 @@ host_rewrite
   *(optional, string)* Indicates that during forwarding, the host header will be swapped with this
   value.
 
+.. _config_http_conn_man_route_table_route_auto_host_rewrite:
+
+auto_host_rewrite
+  *(optional, boolean)* Indicates that during forwarding, the host header will be swapped with the
+  hostname of the upstream host chosen by the cluster manager. This option is applicable only when
+  the destination cluster for a route is of type *strict_dns* or *logical_dns*. Setting this to true
+  with other cluster types has no effect. *auto_host_rewrite* and *host_rewrite* are mutually exclusive 
+  options. Only one can be specified.
+
 .. _config_http_conn_man_route_table_route_case_sensitive:
 
 case_sensitive

diff --git a/docs/intro/arch_overview/http_routing.rst b/docs/intro/arch_overview/http_routing.rst
@@ -22,7 +22,9 @@ request. The router filter supports the following features:
   level.
 * :ref:`Path <config_http_conn_man_route_table_route_path_redirect>`/:ref:`host
   <config_http_conn_man_route_table_route_host_redirect>` redirection at the route level.
-* :ref:`Host rewriting <config_http_conn_man_route_table_route_host_rewrite>`.
+* :ref:`Explicit host rewriting <config_http_conn_man_route_table_route_host_rewrite>`.
+* :ref:`Automatic host rewriting <config_http_conn_man_route_table_route_auto_host_rewrite>` based on
+  the DNS name of the selected upstream host.
 * :ref:`Prefix rewriting <config_http_conn_man_route_table_route_prefix_rewrite>`.
 * :ref:`Request retries <arch_overview_http_routing_retry>` specified either via HTTP header or via
   route configuration.

diff --git a/include/envoy/router/router.h b/include/envoy/router/router.h
@@ -220,6 +220,11 @@ class RouteEntry {
    * @return const VirtualHost& the virtual host that owns the route.
    */
   virtual const VirtualHost& virtualHost() const PURE;
+
+  /**
+   * @return bool true if the :authority header should be overwritten with the upstream hostname.
+   */
+  virtual bool autoHostRewrite() const PURE;
 };
 
 /**

diff --git a/include/envoy/upstream/host_description.h b/include/envoy/upstream/host_description.h
@@ -50,6 +50,12 @@ class HostDescription {
    */
   virtual Outlier::DetectorHostSink& outlierDetector() const PURE;
 
+  /**
+   * @return the hostname associated with the host if any.
+   * Empty string "" indicates that hostname is not a DNS name.
+   */
+  virtual const std::string& hostname() const PURE;
+
   /**
    * @return the address used to connect to the host.
    */

diff --git a/source/common/http/async_client_impl.h b/source/common/http/async_client_impl.h
@@ -129,6 +129,7 @@ class AsyncStreamImpl : public AsyncClient::Stream,
       return nullptr;
     }
     const Router::VirtualHost& virtualHost() const override { return virtual_host_; }
+    bool autoHostRewrite() const override { return false; }
 
     static const NullRateLimitPolicy rate_limit_policy_;
     static const NullRetryPolicy retry_policy_;

diff --git a/source/common/json/config_schemas.cc b/source/common/json/config_schemas.cc
@@ -488,6 +488,7 @@ const std::string Json::Schema::ROUTE_ENTRY_CONFIGURATION_SCHEMA(R"EOF(
       "path_redirect" : {"type" : "string"},
       "prefix_rewrite" : {"type" : "string"},
       "host_rewrite" : {"type" : "string"},
+      "auto_host_rewrite" : {"type" : "boolean"},
       "case_sensitive" : {"type" : "boolean"},
       "timeout_ms" : {"type" : "integer"},
       "runtime" : {

diff --git a/source/common/router/config_impl.cc b/source/common/router/config_impl.cc
@@ -94,6 +94,7 @@ RouteEntryImplBase::RouteEntryImplBase(const VirtualHostImpl& vhost, const Json:
     : case_sensitive_(route.getBoolean("case_sensitive", true)),
       prefix_rewrite_(route.getString("prefix_rewrite", "")),
       host_rewrite_(route.getString("host_rewrite", "")), vhost_(vhost),
+      auto_host_rewrite_(route.getBoolean("auto_host_rewrite", false)),
       cluster_name_(route.getString("cluster", "")),
       cluster_header_name_(route.getString("cluster_header", "")),
       timeout_(route.getInteger("timeout_ms", DEFAULT_ROUTE_TIMEOUT_MS)),
@@ -105,6 +106,12 @@ RouteEntryImplBase::RouteEntryImplBase(const VirtualHostImpl& vhost, const Json:
 
   route.validateSchema(Json::Schema::ROUTE_ENTRY_CONFIGURATION_SCHEMA);
 
+  // Route can either have a host_rewrite with fixed host header or automatic host rewrite
+  // based on the DNS name of the instance in the backing cluster.
+  if (auto_host_rewrite_ && !host_rewrite_.empty()) {
+    throw EnvoyException("routes cannot have both auto_host_rewrite and host_rewrite options set");
+  }
+
   bool have_weighted_clusters = route.hasObject("weighted_clusters");
   bool have_cluster =
       !cluster_name_.empty() || !cluster_header_name_.get().empty() || have_weighted_clusters;

diff --git a/source/common/router/config_impl.h b/source/common/router/config_impl.h
@@ -212,6 +212,7 @@ class RouteEntryImplBase : public RouteEntry,
   }
   std::chrono::milliseconds timeout() const override { return timeout_; }
   const VirtualHost& virtualHost() const override { return vhost_; }
+  bool autoHostRewrite() const override { return auto_host_rewrite_; }
 
   // Router::RedirectEntry
   std::string newPath(const Http::HeaderMap& headers) const override;
@@ -258,6 +259,7 @@ class RouteEntryImplBase : public RouteEntry,
     }
 
     const VirtualHost& virtualHost() const override { return parent_->virtualHost(); }
+    bool autoHostRewrite() const override { return parent_->autoHostRewrite(); }
 
     // Router::Route
     const RedirectEntry* redirectEntry() const override { return nullptr; }
@@ -301,6 +303,7 @@ class RouteEntryImplBase : public RouteEntry,
   static const uint64_t DEFAULT_ROUTE_TIMEOUT_MS = 15000;
 
   const VirtualHostImpl& vhost_;
+  const bool auto_host_rewrite_;
   const std::string cluster_name_;
   const Http::LowerCaseString cluster_header_name_;
   const std::chrono::milliseconds timeout_;

diff --git a/source/common/router/router.cc b/source/common/router/router.cc
@@ -704,6 +704,10 @@ void Filter::UpstreamRequest::onPoolReady(Http::StreamEncoder& request_encoder,
   conn_pool_stream_handle_ = nullptr;
   request_encoder_ = &request_encoder;
   calling_encode_headers_ = true;
+  if (parent_.route_entry_->autoHostRewrite() && !host->hostname().empty()) {
+    parent_.downstream_headers_->Host()->value(host->hostname());
+  }
+
   request_encoder.encodeHeaders(*parent_.downstream_headers_,
                                 !buffered_request_body_ && encode_complete_ && !encode_trailers_);
   calling_encode_headers_ = false;

diff --git a/source/common/upstream/logical_dns_cluster.cc b/source/common/upstream/logical_dns_cluster.cc
@@ -21,7 +21,7 @@ LogicalDnsCluster::LogicalDnsCluster(const Json::Object& config, Runtime::Loader
   }
 
   dns_url_ = hosts_json[0]->getString("url");
-  Network::Utility::hostFromTcpUrl(dns_url_);
+  hostname_ = Network::Utility::hostFromTcpUrl(dns_url_);
   Network::Utility::portFromTcpUrl(dns_url_);
 
   // This must come before startResolve(), since the resolve callback relies on
@@ -70,8 +70,8 @@ void LogicalDnsCluster::startResolve() {
             //       the friendly DNS name in that output, but currently there is no way to
             //       express a DNS name inside of an Address::Instance. For now this is OK but
             //       we might want to do better again later.
-            logical_host_.reset(
-                new LogicalHost(info_, Network::Utility::resolveUrl("tcp://0.0.0.0:0"), *this));
+            logical_host_.reset(new LogicalHost(
+                info_, hostname_, Network::Utility::resolveUrl("tcp://0.0.0.0:0"), *this));
             HostVectorPtr new_hosts(new std::vector<HostPtr>());
             new_hosts->emplace_back(logical_host_);
             updateHosts(new_hosts, createHealthyHostList(*new_hosts), empty_host_lists_,

diff --git a/source/common/upstream/logical_dns_cluster.h b/source/common/upstream/logical_dns_cluster.h
@@ -42,9 +42,9 @@ class LogicalDnsCluster : public ClusterImplBase {
 
 private:
   struct LogicalHost : public HostImpl {
-    LogicalHost(ClusterInfoPtr cluster, Network::Address::InstancePtr address,
-                LogicalDnsCluster& parent)
-        : HostImpl(cluster, address, false, 1, ""), parent_(parent) {}
+    LogicalHost(ClusterInfoPtr cluster, const std::string& hostname,
+                Network::Address::InstancePtr address, LogicalDnsCluster& parent)
+        : HostImpl(cluster, hostname, address, false, 1, ""), parent_(parent) {}
 
     // Upstream::Host
     CreateConnectionData createConnection(Event::Dispatcher& dispatcher) const override;
@@ -63,6 +63,7 @@ class LogicalDnsCluster : public ClusterImplBase {
       return logical_host_->outlierDetector();
     }
     const HostStats& stats() const override { return logical_host_->stats(); }
+    const std::string& hostname() const override { return logical_host_->hostname(); }
     Network::Address::InstancePtr address() const override { return address_; }
     const std::string& zone() const override { return EMPTY_STRING; }
 
@@ -88,6 +89,7 @@ class LogicalDnsCluster : public ClusterImplBase {
   bool initialized_;
   Event::TimerPtr resolve_timer_;
   std::string dns_url_;
+  std::string hostname_;
   Network::Address::InstancePtr current_resolved_address_;
   HostPtr logical_host_;
   Network::ActiveDnsQuery* active_dns_query_{};

diff --git a/source/common/upstream/sds.cc b/source/common/upstream/sds.cc
@@ -32,8 +32,8 @@ void SdsClusterImpl::parseResponse(const Http::Message& response) {
     }
 
     new_hosts.emplace_back(
-        new HostImpl(info_, Network::Address::InstancePtr{new Network::Address::Ipv4Instance(
-                                host->getString("ip_address"), host->getInteger("port"))},
+        new HostImpl(info_, "", Network::Address::InstancePtr{new Network::Address::Ipv4Instance(
+                                    host->getString("ip_address"), host->getInteger("port"))},
                      canary, weight, zone));
   }
 

diff --git a/source/common/upstream/upstream_impl.cc b/source/common/upstream/upstream_impl.cc
@@ -267,8 +267,8 @@ StaticClusterImpl::StaticClusterImpl(const Json::Object& config, Runtime::Loader
   std::vector<Json::ObjectPtr> hosts_json = config.getObjectArray("hosts");
   HostVectorPtr new_hosts(new std::vector<HostPtr>());
   for (Json::ObjectPtr& host : hosts_json) {
-    new_hosts->emplace_back(HostPtr{
-        new HostImpl(info_, Network::Utility::resolveUrl(host->getString("url")), false, 1, "")});
+    new_hosts->emplace_back(HostPtr{new HostImpl(
+        info_, "", Network::Utility::resolveUrl(host->getString("url")), false, 1, "")});
   }
 
   updateHosts(new_hosts, createHealthyHostList(*new_hosts), empty_host_lists_, empty_host_lists_,
@@ -420,10 +420,11 @@ void StrictDnsClusterImpl::ResolveTarget::startResolve() {
           //       address that has port in it. We need to both support IPv6 as well as potentially
           //       move port handling into the DNS interface itself, which would work better for
           //       SRV.
-          new_hosts.emplace_back(new HostImpl(
-              parent_.info_, Network::Address::InstancePtr{new Network::Address::Ipv4Instance(
-                                 address->ip()->addressAsString(), port_)},
-              false, 1, ""));
+          new_hosts.emplace_back(
+              new HostImpl(parent_.info_, dns_address_,
+                           Network::Address::InstancePtr{new Network::Address::Ipv4Instance(
+                               address->ip()->addressAsString(), port_)},
+                           false, 1, ""));
         }
 
         std::vector<HostPtr> hosts_added;

diff --git a/source/common/upstream/upstream_impl.h b/source/common/upstream/upstream_impl.h
@@ -25,9 +25,9 @@ namespace Upstream {
  */
 class HostDescriptionImpl : virtual public HostDescription {
 public:
-  HostDescriptionImpl(ClusterInfoPtr cluster, Network::Address::InstancePtr address, bool canary,
-                      const std::string& zone)
-      : cluster_(cluster), address_(address), canary_(canary), zone_(zone),
+  HostDescriptionImpl(ClusterInfoPtr cluster, const std::string& hostname,
+                      Network::Address::InstancePtr address, bool canary, const std::string& zone)
+      : cluster_(cluster), hostname_(hostname), address_(address), canary_(canary), zone_(zone),
         stats_{ALL_HOST_STATS(POOL_COUNTER(stats_store_), POOL_GAUGE(stats_store_))} {}
 
   // Upstream::HostDescription
@@ -41,11 +41,13 @@ class HostDescriptionImpl : virtual public HostDescription {
     }
   }
   const HostStats& stats() const override { return stats_; }
+  const std::string& hostname() const override { return hostname_; }
   Network::Address::InstancePtr address() const override { return address_; }
   const std::string& zone() const override { return zone_; }
 
 protected:
   ClusterInfoPtr cluster_;
+  const std::string hostname_;
   Network::Address::InstancePtr address_;
   const bool canary_;
   const std::string zone_;
@@ -64,9 +66,10 @@ class HostImpl : public HostDescriptionImpl,
                  public Host,
                  public std::enable_shared_from_this<HostImpl> {
 public:
-  HostImpl(ClusterInfoPtr cluster, Network::Address::InstancePtr address, bool canary,
-           uint32_t initial_weight, const std::string& zone)
-      : HostDescriptionImpl(cluster, address, canary, zone) {
+  HostImpl(ClusterInfoPtr cluster, const std::string& hostname,
+           Network::Address::InstancePtr address, bool canary, uint32_t initial_weight,
+           const std::string& zone)
+      : HostDescriptionImpl(cluster, hostname, address, canary, zone) {
     weight(initial_weight);
   }
 

diff --git a/test/common/filter/tcp_proxy_test.cc b/test/common/filter/tcp_proxy_test.cc
@@ -312,7 +312,7 @@ class TcpProxyTest : public testing::Test {
       Upstream::MockHost::MockCreateConnectionData conn_info;
       conn_info.connection_ = upstream_connection_;
       conn_info.host_.reset(
-          new Upstream::HostImpl(cluster_manager_.cluster_.info_,
+          new Upstream::HostImpl(cluster_manager_.cluster_.info_, "",
                                  Network::Utility::resolveUrl("tcp://127.0.0.1:80"), false, 1, ""));
       EXPECT_CALL(cluster_manager_, tcpConnForCluster_("fake_cluster")).WillOnce(Return(conn_info));
       EXPECT_CALL(*upstream_connection_, addReadFilter(_))

diff --git a/test/common/http/access_log/access_log_impl_test.cc b/test/common/http/access_log/access_log_impl_test.cc
@@ -140,7 +140,7 @@ TEST_F(AccessLogImplTest, NoFilter) {
 TEST_F(AccessLogImplTest, UpstreamHost) {
   std::shared_ptr<Upstream::MockClusterInfo> cluster{new Upstream::MockClusterInfo()};
   request_info_.upstream_host_ = std::make_shared<Upstream::HostDescriptionImpl>(
-      cluster, Network::Utility::resolveUrl("tcp://10.0.0.5:1234"), false, "");
+      cluster, "", Network::Utility::resolveUrl("tcp://10.0.0.5:1234"), false, "");
 
   std::string json = R"EOF(
       {

diff --git a/test/common/http/codec_client_test.cc b/test/common/http/codec_client_test.cc
@@ -49,7 +49,7 @@ class CodecClientTest : public testing::Test {
   Network::ReadFilterPtr filter_;
   std::shared_ptr<Upstream::MockClusterInfo> cluster_{new NiceMock<Upstream::MockClusterInfo>()};
   Upstream::HostDescriptionPtr host_{new Upstream::HostDescriptionImpl(
-      cluster_, Network::Utility::resolveUrl("tcp://127.0.0.1:80"), false, "")};
+      cluster_, "", Network::Utility::resolveUrl("tcp://127.0.0.1:80"), false, "")};
 };
 
 TEST_F(CodecClientTest, BasicHeaderOnlyResponse) {

diff --git a/test/common/http/http1/conn_pool_test.cc b/test/common/http/http1/conn_pool_test.cc
@@ -30,10 +30,11 @@ namespace Http1 {
 class ConnPoolImplForTest : public ConnPoolImpl {
 public:
   ConnPoolImplForTest(Event::MockDispatcher& dispatcher, Upstream::ClusterInfoPtr cluster)
-      : ConnPoolImpl(dispatcher, Upstream::HostPtr{new Upstream::HostImpl(
-                                     cluster, Network::Utility::resolveUrl("tcp://127.0.0.1:9000"),
-                                     false, 1, "")},
-                     Upstream::ResourcePriority::Default),
+      : ConnPoolImpl(
+            dispatcher,
+            Upstream::HostPtr{new Upstream::HostImpl(
+                cluster, "", Network::Utility::resolveUrl("tcp://127.0.0.1:9000"), false, 1, "")},
+            Upstream::ResourcePriority::Default),
         mock_dispatcher_(dispatcher) {}
 
   ~ConnPoolImplForTest() {

diff --git a/test/common/http/http2/conn_pool_test.cc b/test/common/http/http2/conn_pool_test.cc
@@ -88,7 +88,7 @@ class Http2ConnPoolImplTest : public testing::Test {
   NiceMock<Event::MockDispatcher> dispatcher_;
   std::shared_ptr<Upstream::MockClusterInfo> cluster_{new NiceMock<Upstream::MockClusterInfo>()};
   Upstream::HostPtr host_{new Upstream::HostImpl(
-      cluster_, Network::Utility::resolveUrl("tcp://127.0.0.1:80"), false, 1, "")};
+      cluster_, "", Network::Utility::resolveUrl("tcp://127.0.0.1:80"), false, 1, "")};
   TestConnPoolImpl pool_;
   std::vector<TestCodecClient> test_clients_;
   NiceMock<Runtime::MockLoader> runtime_;

diff --git a/test/common/network/filter_manager_impl_test.cc b/test/common/network/filter_manager_impl_test.cc
@@ -149,7 +149,7 @@ TEST_F(NetworkFilterManagerTest, RateLimitAndTcpProxy) {
   Upstream::MockHost::MockCreateConnectionData conn_info;
   conn_info.connection_ = upstream_connection;
   conn_info.host_.reset(new Upstream::HostImpl(
-      cm.cluster_.info_, Utility::resolveUrl("tcp://127.0.0.1:80"), false, 1, ""));
+      cm.cluster_.info_, "", Utility::resolveUrl("tcp://127.0.0.1:80"), false, 1, ""));
   EXPECT_CALL(cm, tcpConnForCluster_("fake_cluster")).WillOnce(Return(conn_info));
 
   request_callbacks->complete(RateLimit::LimitStatus::OK);

diff --git a/test/common/redis/conn_pool_impl_test.cc b/test/common/redis/conn_pool_impl_test.cc
@@ -30,7 +30,7 @@ class RedisClientImplTest : public testing::Test, public DecoderFactory {
     Upstream::MockHost::MockCreateConnectionData conn_info;
     conn_info.connection_ = upstream_connection_;
     conn_info.host_.reset(new Upstream::HostImpl(
-        cm_.cluster_.info_, Network::Utility::resolveUrl("tcp://127.0.0.1:80"), false, 1, ""));
+        cm_.cluster_.info_, "", Network::Utility::resolveUrl("tcp://127.0.0.1:80"), false, 1, ""));
     EXPECT_CALL(cm_, tcpConnForCluster_("foo")).WillOnce(Return(conn_info));
     EXPECT_CALL(*upstream_connection_, addReadFilter(_))
         .WillOnce(SaveArg<0>(&upstream_read_filter_));

diff --git a/test/common/router/config_impl_test.cc b/test/common/router/config_impl_test.cc
@@ -412,6 +412,32 @@ TEST(RouteMatcherTest, Priority) {
   }
 }
 
+TEST(RouteMatcherTest, NoHostRewriteAndAutoRewrite) {
+  std::string json = R"EOF(
+{
+  "virtual_hosts": [
+    {
+      "name": "local_service",
+      "domains": ["*"],
+      "routes": [
+        {
+          "prefix": "/",
+          "cluster": "local_service",
+          "host_rewrite": "foo",
+          "auto_host_rewrite" : true
+        }
+      ]
+    }
+  ]
+}
+  )EOF";
+
+  Json::ObjectPtr loader = Json::Factory::LoadFromString(json);
+  NiceMock<Runtime::MockLoader> runtime;
+  NiceMock<Upstream::MockClusterManager> cm;
+  EXPECT_THROW(ConfigImpl(*loader, runtime, cm, true), EnvoyException);
+}
+
 TEST(RouteMatcherTest, HeaderMatchedRouting) {
   std::string json = R"EOF(
 {