On demand loading of ScopedRouteConfiguration

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

@@ -1,17 +1,19 @@
 .. _config_http_filters_on_demand:
 
-On-demand VHDS ans S/RDS Updates
+On-demand VHDS and S/RDS Updates
 ================================
 
+The on demand filter can be used to support either on demand VHDS or S/RDS update if configured in the filter chain.
+
 The on-demand update filter can be used to request a :ref:`virtual host <envoy_v3_api_msg_config.route.v3.VirtualHost>`
 data if it's not already present in the :ref:`Route Configuration <envoy_v3_api_msg_config.route.v3.RouteConfiguration>`. The
 contents of the *Host* or *:authority* header is used to create the on-demand request. For an on-demand
 request to be created, :ref:`VHDS <envoy_v3_api_field_config.route.v3.RouteConfiguration.vhds>` must be enabled and either *Host*
 or *:authority* header be present.
 
-The on-demand update filter can also be used to request a :ref:`Route Configuration <envoy_v3_api_msg_config.route.v3.RouteConfiguration>`
-data if RouteConfiguration is specified to be loaded on demand in the :ref:`Scoped RouteConfiguration <envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>`. The
-contents of the http header is used to find the scope and create the on-demand request. 
+The on-demand update filter can also be used to request a *Route Configuration* data if RouteConfiguration is specified to be 
+loaded on demand in the :ref:`Scoped RouteConfiguration <envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>`. 
+The contents of the http header is used to find the scope and create the on-demand request. 
 
 On-demand VHDS and on-demand S/RDS can not be used at the same time at this point.
 

docs/root/intro/arch_overview/http/http_routing.rst

@@ -59,10 +59,11 @@ Route Scope
 Scoped routing enables Envoy to put constraints on search space of domains and route rules.
 A :ref:`Route Scope<envoy_api_msg_ScopedRouteConfiguration>` associates a key with a :ref:`route table <arch_overview_http_routing_route_table>`.
 For each request, a scope key is computed dynamically by the HTTP connection manager to pick the :ref:`route table<envoy_api_msg_RouteConfiguration>`.
+RouteConfiguration with scope can be loaded on demand with :ref:`v3 API reference <envoy_v3_api_msg_extensions.filters.http.on_demand.v3.OnDemand>` configured and on demand filed in protobuf set to true.
 
 The Scoped RDS (SRDS) API contains a set of :ref:`Scopes <envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>` resources, each defining independent routing configuration,
 along with a :ref:`ScopeKeyBuilder <envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
-defining the key construction algorithm used by Envoy to look up the scope corresponding to each request.
+defining the key construction algorithm used by Envoy to look up the scope corresponding to each request. 
 
 For example, for the following scoped route configuration, Envoy will look into the "addr" header value, split the header value by ";" first, and use the first value for key 'x-foo-key' as the scope key.
 If the "addr" header value is "foo=1;x-foo-key=127.0.0.1;x-bar-key=1.1.1.1", then "127.0.0.1" will be computed as the scope key to look up for corresponding route configuration.

source/common/http/conn_manager_impl.cc

@@ -496,6 +496,7 @@ void ConnectionManagerImpl::RdsRouteConfigUpdateRequester::requestRouteConfigUpd
   } else if (parent_.snapped_scoped_routes_config_ != nullptr) {
     Router::ScopeKeyPtr scope_key = parent_.snapped_scoped_routes_config_->computeScopeKey(
         *parent_.filter_manager_.requestHeaders());
+    // If scope_key is not null, the scope exists but RouteConfiguration is not initialized.
     if (scope_key != nullptr) {
       // On demand srds
       requestSrdsUpdate(std::move(scope_key), thread_local_dispatcher,
@@ -508,7 +509,7 @@ void ConnectionManagerImpl::RdsRouteConfigUpdateRequester::requestRouteConfigUpd
 }
 
 void ConnectionManagerImpl::RdsRouteConfigUpdateRequester::requestVhdsUpdate(
-    const std::string host_header, Event::Dispatcher& thread_local_dispatcher,
+    const std::string& host_header, Event::Dispatcher& thread_local_dispatcher,
     Http::RouteConfigUpdatedCallbackSharedPtr route_config_updated_cb) {
   route_config_provider_->requestVirtualHostsUpdate(host_header, thread_local_dispatcher,
                                                     std::move(route_config_updated_cb));

source/common/http/conn_manager_impl.h

@@ -118,16 +118,17 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
                                   ActiveStream& parent)
         : route_config_provider_(route_config_provider), parent_(parent) {}
 
-    // Only on demand update for ScopeRdsConfigProvider is supported.
-    // InlineScopedRoutesConfigProvider will cast to nullptr in this ctor.
     RdsRouteConfigUpdateRequester(Config::ConfigProvider* scoped_route_config_provider,
                                   ActiveStream& parent)
+        // Only on demand update for ScopeRdsConfigProvider is supported.
+        // InlineScopedRoutesConfigProvider will cast to nullptr in this ctor.
         : scoped_route_config_provider_(
               dynamic_cast<Router::ScopedRdsConfigProvider*>(scoped_route_config_provider)),
           parent_(parent) {}
+
     void
     requestRouteConfigUpdate(Http::RouteConfigUpdatedCallbackSharedPtr route_config_updated_cb);
-    void requestVhdsUpdate(const std::string host_header,
+    void requestVhdsUpdate(const std::string& host_header,
                            Event::Dispatcher& thread_local_dispatcher,
                            Http::RouteConfigUpdatedCallbackSharedPtr route_config_updated_cb);
     void requestSrdsUpdate(Router::ScopeKeyPtr scope_key,

source/common/router/scoped_rds.cc

@@ -189,6 +189,7 @@ void ScopedRdsConfigSubscription::RdsRouteConfigProviderHelper::maybeInitRdsConf
   }
 
   // Create a init_manager to create a rds provider.
+  // No transitive warming dependency here because only on demand update reach this point.
   std::unique_ptr<Init::ManagerImpl> srds_init_mgr =
       std::make_unique<Init::ManagerImpl>(fmt::format("SRDS on demand init manager."));
   std::unique_ptr<Cleanup> srds_initialization_continuation =
@@ -253,6 +254,9 @@ bool ScopedRdsConfigSubscription::addOrUpdateScopes(
               scoped_route_info->scopeName(), version_info);
   }
 
+  // scoped_route_info of both eager loading and on demand scope will be propagated to work
+  // threads. Upon a scoped RouteConfiguration miss, if the scope exists, an on demand update
+  // callback will be posted to main thread.
   if (!updated_scopes.empty()) {
     applyConfigUpdate([updated_scopes](ConfigProvider::ConfigConstSharedPtr config)
                           -> ConfigProvider::ConfigConstSharedPtr {

test/common/router/scoped_rds_test.cc

@@ -1453,15 +1453,17 @@ on_demand: true
                             Stats::Gauge::ImportMode::Accumulate)
                      .value());
   // All the on demand updated callbacks will be executed when the route table comes.
-  for (int i = 0; i < 5; i++) {
+  {
     ScopeKeyPtr scope_key = getScopedRdsProvider()->config<ScopedConfigImpl>()->computeScopeKey(
         TestRequestHeaderMapImpl{{"Addr", "x-foo-key;x-foo-key"}});
-    std::function<void(bool)> route_config_updated_cb = [](bool) {};
+    std::function<void(bool)> route_config_updated_cb = [](bool scope_exist) {
+      EXPECT_TRUE(scope_exist);
+    };
     getScopedRdsProvider()->onDemandRdsUpdate(std::move(scope_key), event_dispatcher_,
                                               std::move(route_config_updated_cb));
   }
   // After on demand request, push rds update, the callbacks will be executed.
-  EXPECT_CALL(event_dispatcher_, post(_)).Times(5);
+  EXPECT_CALL(event_dispatcher_, post(_)).Times(1);
   pushRdsConfig({"foo_routes"}, "111");
 
   ScopeKeyPtr scope_key = getScopedRdsProvider()->config<ScopedConfigImpl>()->computeScopeKey(
@@ -1473,7 +1475,10 @@ on_demand: true
                             Stats::Gauge::ImportMode::Accumulate)
                      .value());
   EXPECT_CALL(event_dispatcher_, post(_)).Times(1);
-  std::function<void(bool)> route_config_updated_cb = [](bool) {};
+  // Scope no longer exists after srds update.
+  std::function<void(bool)> route_config_updated_cb = [](bool scope_exist) {
+    EXPECT_FALSE(scope_exist);
+  };
   getScopedRdsProvider()->onDemandRdsUpdate(std::move(scope_key), event_dispatcher_,
                                             std::move(route_config_updated_cb));
 }

test/integration/scoped_rds_integration_test.cc

@@ -732,5 +732,50 @@ on_demand: true
   }
 }
 
+TEST_P(ScopedRdsIntegrationTest, OnDemandUpdateAfterActiveStreamDestroyed) {
+  config_helper_.addFilter(R"EOF(
+    name: envoy.filters.http.on_demand
+    )EOF");
+  const std::string scope_route1 = R"EOF(
+name: foo_scope1
+route_configuration_name: foo_route1
+on_demand: true
+key:
+  fragments:
+    - string_key: foo
+)EOF";
+  on_server_init_function_ = [this, &scope_route1]() {
+    createScopedRdsStream();
+    sendSrdsResponse({scope_route1}, {scope_route1}, {}, "1");
+  };
+  initialize();
+  registerTestServerPorts({"http"});
+  fake_upstreams_[0]->set_allow_unexpected_disconnects(true);
+
+  const std::string route_config_tmpl = R"EOF(
+      name: {}
+      virtual_hosts:
+      - name: integration
+        domains: ["*"]
+        routes:
+        - match: {{ prefix: "/" }}
+          route: {{ cluster: {} }}
+)EOF";
+  codec_client_ = makeHttpConnection(makeClientConnection((lookupPort("http"))));
+  // Request that match lazily loaded scope will trigger on demand loading.
+  auto response = codec_client_->makeHeaderOnlyRequest(
+      Http::TestRequestHeaderMapImpl{{":method", "GET"},
+                                     {":path", "/meh"},
+                                     {":authority", "host"},
+                                     {":scheme", "http"},
+                                     {"Addr", "x-foo-key=foo"}});
+  // Close the connection and destroy the active stream.
+  cleanupUpstreamAndDownstream();
+  // Push rds update and there is noexception thrown.
+  createRdsStream("foo_route1");
+  sendRdsResponse(fmt::format(route_config_tmpl, "foo_route1", "cluster_0"), "1");
+  test_server_->waitForCounterGe("http.config_test.rds.foo_route1.update_success", 1);
+}
+
 } // namespace
 } // namespace Envoy